Shuu12121/github-file-programs-dataset-rust

repo stringlengths 6 65	file_url stringlengths 81 311	file_path stringlengths 6 227	content stringlengths 0 32.8k	language stringclasses 1 value	license stringclasses 7 values	commit_sha stringlengths 40 40	retrieved_at stringdate 2026-01-04 15:31:58 2026-01-04 20:25:31	truncated bool 2 classes
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/viewer/markdown/document/bodytext/list_header.rs	crates/hwp-core/src/viewer/markdown/document/bodytext/list_header.rs	//! ListHeader conversion to Markdown //! ListHeader를 마크다운으로 변환하는 모듈 //! //! 스펙 문서 매핑: 표 57 - 본문의 데이터 레코드, LIST_HEADER (HWPTAG_BEGIN + 56) //! Spec mapping: Table 57 - BodyText data records, LIST_HEADER (HWPTAG_BEGIN + 56) //! //! Note: 실제 변환은 convert_paragraph_to_markdown에서 처리되므로 //! 이 모듈은 향후 확장을 위해 준비되었습니다. //! Note: Actual conversion is handled in convert_paragraph_to_markdown, //! so this module is prepared for future expansion. //! //! This module is currently empty but reserved for future ListHeader-specific conversion logic. //! 이 모듈은 현재 비어있지만 향후 ListHeader 전용 변환 로직을 위해 예약되어 있습니다.	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/viewer/markdown/document/bodytext/paragraph.rs	crates/hwp-core/src/viewer/markdown/document/bodytext/paragraph.rs	/// Paragraph conversion to Markdown /// 문단을 마크다운으로 변환하는 모듈 /// /// 스펙 문서 매핑: 표 57 - 본문의 데이터 레코드 /// Spec mapping: Table 57 - BodyText data records use crate::document::bodytext::CharShapeInfo; use crate::document::CharShape; use crate::document::{HwpDocument, Paragraph, ParagraphRecord}; use crate::viewer::markdown::collect::collect_text_and_images_from_paragraph; use crate::viewer::markdown::document::bodytext::para_text::{ convert_para_text_to_markdown, convert_para_text_to_markdown_with_char_shapes, }; use crate::viewer::markdown::document::bodytext::shape_component::convert_shape_component_children_to_markdown; use crate::viewer::markdown::document::bodytext::shape_component_picture::convert_shape_component_picture_to_markdown; use crate::viewer::markdown::document::bodytext::table::convert_table_to_markdown; use crate::viewer::markdown::utils::{ convert_to_outline_with_number, is_text_part, OutlineNumberTracker, }; use crate::viewer::markdown::MarkdownOptions; /// Convert a paragraph to markdown /// 문단을 마크다운으로 변환 pub fn convert_paragraph_to_markdown( paragraph: &Paragraph, document: &HwpDocument, options: &MarkdownOptions, tracker: &mut OutlineNumberTracker, ) -> String { if paragraph.records.is_empty() { return String::new(); } let mut parts = Vec::new(); let mut text_parts = Vec::new(); // 같은 문단 내의 텍스트 레코드들을 모음 / Collect text records in the same paragraph let mut char_shapes: Vec<CharShapeInfo> = Vec::new(); // 문단의 글자 모양 정보 수집 / Collect character shape information for paragraph // 먼저 ParaCharShape 레코드를 수집 / First collect ParaCharShape records for record in &paragraph.records { if let ParagraphRecord::ParaCharShape { shapes } = record { char_shapes.extend(shapes.clone()); } } // CharShape를 가져오는 클로저 / Closure to get CharShape let get_char_shape = \|shape_id: u32\| -> Option<&CharShape> { document.doc_info.char_shapes.get(shape_id as usize) }; // Process all records in order / 모든 레코드를 순서대로 처리 for record in &paragraph.records { match record { ParagraphRecord::ParaText { text, control_char_positions, inline_control_params: _, .. } => { // ParaText 변환 / Convert ParaText // 표 셀 내부의 텍스트는 이미 Table.cells에 포함되어 convert_table_to_markdown에서 처리되므로 // 여기서는 표 앞뒤의 일반 텍스트도 정상적으로 처리됨 // Text inside table cells is already included in Table.cells and processed in convert_table_to_markdown, // so regular text before/after tables is also processed normally here let text_md = if !char_shapes.is_empty() { convert_para_text_to_markdown_with_char_shapes( text, control_char_positions, &char_shapes, Some(&get_char_shape), ) } else { convert_para_text_to_markdown(text, control_char_positions) }; if let Some(text_md) = text_md { // 같은 문단 내의 텍스트는 나중에 합침 / Text in the same paragraph will be combined later text_parts.push(text_md); } } ParagraphRecord::ShapeComponent { shape_component: _, children, } => { // SHAPE_COMPONENT의 children을 재귀적으로 처리 / Recursively process SHAPE_COMPONENT's children let shape_parts = convert_shape_component_children_to_markdown( children, document, options.image_output_dir.as_deref(), tracker, ); parts.extend(shape_parts); } ParagraphRecord::ShapeComponentPicture { shape_component_picture, } => { // ShapeComponentPicture 변환 / Convert ShapeComponentPicture if let Some(image_md) = convert_shape_component_picture_to_markdown( shape_component_picture, document, options.image_output_dir.as_deref(), ) { parts.push(image_md); } } ParagraphRecord::CtrlHeader { header, children, paragraphs: ctrl_paragraphs, .. } => { // 마크다운으로 표현할 수 없는 컨트롤 헤더는 건너뜀 / Skip control headers that cannot be expressed in markdown use crate::viewer::markdown::utils::should_process_control_header; if !should_process_control_header(header) { // CTRL_HEADER 내부의 직접 문단 처리 / Process direct paragraphs inside CTRL_HEADER for para in ctrl_paragraphs { let para_md = convert_paragraph_to_markdown(para, document, options, tracker); if !para_md.is_empty() { parts.push(para_md); } } // CTRL_HEADER의 children 처리 (예: SHAPE_COMPONENT_PICTURE) / Process CTRL_HEADER's children (e.g., SHAPE_COMPONENT_PICTURE) for child in children { match child { ParagraphRecord::ShapeComponentPicture { shape_component_picture, } => { if let Some(image_md) = convert_shape_component_picture_to_markdown( shape_component_picture, document, options.image_output_dir.as_deref(), ) { parts.push(image_md); } } _ => { // 기타 자식 레코드는 무시 (이미 처리된 경우만 도달) / Ignore other child records (only reached if already processed) } } } continue; // 이 컨트롤 헤더는 더 이상 처리하지 않음 / Don't process this control header further } // 컨트롤 헤더의 자식 레코드 처리 (레벨 2, 예: 테이블, 그림 등) / Process control header children (level 2, e.g., table, images, etc.) let mut has_table = false; // 표 셀 내부의 텍스트와 이미지를 수집하여 셀 내부 문단인지 확인 // Collect text and images from paragraphs in Table.cells to check if they are cell content // 포인터 비교는 복사된 객체에서 실패할 수 있으므로 텍스트 내용과 이미지 ID로 비교 // Pointer comparison may fail with copied objects, so compare by text content and image ID let mut table_cell_texts: std::collections::HashSet<String> = std::collections::HashSet::new(); let mut table_cell_image_ids: std::collections::HashSet<u16> = std::collections::HashSet::new(); let mut table_cell_para_ids: std::collections::HashSet<u32> = std::collections::HashSet::new(); // 표 셀 내부 문단의 instance_id 수집 let mut table_opt: Option<&crate::document::bodytext::Table> = None; let mut table_index: Option<usize> = None; let is_table_control = header.ctrl_id == crate::document::CtrlId::TABLE; // 먼저 TABLE을 찾아서 table_opt에 저장 / First find TABLE and store in table_opt let children_slice: &[ParagraphRecord] = children; for (idx, child) in children_slice.iter().enumerate() { if let ParagraphRecord::Table { table } = child { table_opt = Some(table); table_index = Some(idx); break; } } if let Some(table) = table_opt { for cell in &table.cells { for para in &cell.paragraphs { // 문단의 instance_id 수집 (0이 아닌 경우만) / Collect paragraph instance_id (only if not 0) if para.para_header.instance_id != 0 { table_cell_para_ids.insert(para.para_header.instance_id); } // ParaText의 텍스트를 수집 / Collect text from ParaText // 재귀적으로 모든 레코드를 확인하여 이미지 ID 수집 / Recursively check all records to collect image IDs collect_text_and_images_from_paragraph( para, &mut table_cell_texts, &mut table_cell_image_ids, ); } } } // libhwp 방식: 파서 단계에서 TABLE 이전/이후의 LIST_HEADER를 children에 추가하지 않으므로 // 여기서는 처리하지 않음 // libhwp approach: LIST_HEADERs (before/after TABLE) are not added to children in parser stage, // so we don't process them here // TABLE 이전의 LIST_HEADER는 캡션으로 별도 처리되고, // TABLE 이후의 LIST_HEADER는 셀로만 처리됨 // LIST_HEADERs before TABLE are processed as captions separately, // and LIST_HEADERs after TABLE are only processed as cells // 컨트롤 헤더의 자식 레코드들을 순회하며 처리 / Iterate through control header's child records and process them let mut index = 0; let children_slice: &[ParagraphRecord] = children; let is_shape_object = header.ctrl_id == crate::document::CtrlId::SHAPE_OBJECT; while index < children_slice.len() { let child = &children_slice[index]; match child { ParagraphRecord::Table { table } => { // 표 변환 / Convert table let table_md = convert_table_to_markdown(table, document, options, tracker); if !table_md.is_empty() { parts.push(table_md); has_table = true; } index += 1; } ParagraphRecord::ListHeader { paragraphs, .. } => { // LIST_HEADER 처리 (표 아래 캡션 등) / Process LIST_HEADER (caption below, etc.) // libhwp 방식: TABLE 이후의 LIST_HEADER는 Table.cells에 포함되어 있으므로 children에서 처리하지 않음 // libhwp approach: LIST_HEADERs after TABLE are included in Table.cells, so don't process in children if let Some(table_idx) = table_index { if index > table_idx && is_table_control { // TABLE 이후의 LIST_HEADER는 이미 Table.cells에 포함되어 있으므로 건너뜀 // LIST_HEADERs after TABLE are already included in Table.cells, so skip // libhwp는 TABLE 이후의 LIST_HEADER를 children에서 처리하지 않고, // TABLE을 읽은 후 명시적으로 각 셀을 순회하며 처리함 // libhwp doesn't process LIST_HEADERs after TABLE in children, // but processes them explicitly when iterating through cells after reading TABLE } else { // 표 앞의 LIST_HEADER는 이미 처리됨 / LIST_HEADER before table is already processed // 표가 없거나 표 셀 내부가 아닌 경우 일반 처리 / General processing if no table or not inside table cell for para in paragraphs { let para_md = convert_paragraph_to_markdown( para, document, options, tracker, ); if !para_md.is_empty() { parts.push(para_md); } } } } else { // 표가 없는 경우 일반 처리 / General processing if no table for para in paragraphs { let para_md = convert_paragraph_to_markdown( para, document, options, tracker, ); if !para_md.is_empty() { parts.push(para_md); } } } index += 1; } ParagraphRecord::ShapeComponent { shape_component: _, children: shape_children, } => { // SHAPE_COMPONENT의 children 처리 (SHAPE_COMPONENT_PICTURE 등) / Process SHAPE_COMPONENT's children (SHAPE_COMPONENT_PICTURE, etc.) // 먼저 표 셀 내부의 이미지인지 확인 / First check if images are inside table cells let mut shape_parts_to_output = Vec::new(); let mut has_image_in_shape = false; for child in shape_children { match child { ParagraphRecord::ShapeComponentPicture { shape_component_picture, } => { // 표 셀 내부의 이미지인지 확인 (bindata_id로 직접 비교) / Check if image is inside table cell (direct comparison by bindata_id) let is_table_cell_image = table_cell_image_ids.contains( &shape_component_picture.picture_info.bindata_id, ); if is_table_cell_image { // 표 셀 내부의 이미지는 표 셀에 이미 포함되므로 여기서는 표시하지 않음 // Images inside table cells are already included in table cells, so don't display here has_image_in_shape = true; } else { // 표 셀 내부가 아닌 경우 이미지 변환 / Convert image if not inside table cell if let Some(image_md) = convert_shape_component_picture_to_markdown( shape_component_picture, document, options.image_output_dir.as_deref(), ) { shape_parts_to_output.push(image_md); has_image_in_shape = true; } } } ParagraphRecord::ListHeader { paragraphs, .. } => { // LIST_HEADER의 paragraphs 처리 (글상자 텍스트) / Process LIST_HEADER's paragraphs (textbox text) for para in paragraphs { let para_md = convert_paragraph_to_markdown( para, document, options, tracker, ); if !para_md.is_empty() { shape_parts_to_output.push(para_md); } } } _ => {} } } // 변환된 부분들을 출력 / Output converted parts for shape_part in shape_parts_to_output { if has_table && has_image_in_shape { // 표가 있고 이미지가 있는 경우, 이미지가 표 셀 내부가 아니므로 출력 // If table exists and image exists, image is not inside table cell, so output parts.push(shape_part); } else if is_shape_object { // SHAPE_OBJECT의 경우 표 밖에서도 이미지를 처리 // For SHAPE_OBJECT, process image even outside table parts.push(shape_part); } else { // 기타 경우에는 출력 // For other cases, output parts.push(shape_part); } } index += 1; } ParagraphRecord::ShapeComponentPicture { shape_component_picture, } => { // ShapeComponentPicture 변환 / Convert ShapeComponentPicture // 표 셀 내부의 이미지인지 확인 / Check if image is inside table cell let is_table_cell_image = table_cell_image_ids .contains(&shape_component_picture.picture_info.bindata_id); // 표 셀 내부의 이미지는 표 셀에 이미 포함되므로 여기서는 표시하지 않음 // Images inside table cells are already included in table cells, so don't display here if !is_table_cell_image { if let Some(image_md) = convert_shape_component_picture_to_markdown( shape_component_picture, document, options.image_output_dir.as_deref(), ) { if has_table { // 표가 있지만 셀 내부가 아닌 경우 (표 위/아래 이미지 등) // Table exists but not inside cell (e.g., image above/below table) parts.push(image_md); } else if is_shape_object { // SHAPE_OBJECT의 경우 표 밖에서도 이미지를 처리 // For SHAPE_OBJECT, process image even outside table parts.push(image_md); } else { // 기타 경우에는 출력 // For other cases, output parts.push(image_md); } } } index += 1; } _ => { // 기타 레코드는 무시 / Ignore other records // CtrlHeader는 이미 위에서 처리됨 / CtrlHeader is already processed above index += 1; } } } // CTRL_HEADER 내부의 직접 문단 처리 / Process direct paragraphs inside CTRL_HEADER for para in ctrl_paragraphs { // 표 셀 내부의 문단인지 확인 / Check if paragraph is inside table cell let is_table_cell = if is_table_control && table_opt.is_some() { // 먼저 instance_id로 확인 (가장 정확, 0이 아닌 경우만) / First check by instance_id (most accurate, only if not 0) let is_table_cell_by_id = !table_cell_para_ids.is_empty() && para.para_header.instance_id != 0 && table_cell_para_ids.contains(&para.para_header.instance_id); // instance_id로 확인되지 않으면 텍스트와 이미지로 확인 / If not found by instance_id, check by text and images if is_table_cell_by_id { true } else { // 재귀적으로 문단에서 텍스트와 이미지를 수집하여 표 셀 내부인지 확인 // Recursively collect text and images from paragraph to check if inside table cell let mut para_texts = std::collections::HashSet::new(); let mut para_image_ids = std::collections::HashSet::new(); collect_text_and_images_from_paragraph( para, &mut para_texts, &mut para_image_ids, ); // 수집한 텍스트나 이미지가 표 셀 내부에 포함되어 있는지 확인 // Check if collected text or images are included in table cells (!para_texts.is_empty() && para_texts .iter() .any(\|text\| table_cell_texts.contains(text))) \|\| (!para_image_ids.is_empty() && para_image_ids .iter() .any(\|id\| table_cell_image_ids.contains(id))) } } else { false }; // 표 셀 내부가 아닌 경우에만 처리 / Only process if not inside table cell if !is_table_cell { let para_md = convert_paragraph_to_markdown(para, document, options, tracker); if !para_md.is_empty() { parts.push(para_md); } } } } _ => { // 기타 레코드는 무시 / Ignore other records } } } // 같은 문단 내의 텍스트를 합침 / Combine text in the same paragraph if !text_parts.is_empty() { let combined_text = text_parts.join(""); // 개요 레벨 확인 및 개요 번호 추가 / Check outline level and add outline number let outline_md = convert_to_outline_with_number( &combined_text, &paragraph.para_header, document, tracker, ); parts.push(outline_md); } // 마크다운 문법에 맞게 개행 처리 / Handle line breaks according to markdown syntax // 텍스트가 연속으로 나올 때는 스페이스 2개 + 개행, 블록 요소 사이는 빈 줄 // For consecutive text: two spaces + newline, for block elements: blank line if parts.is_empty() { return String::new(); } if parts.len() == 1 { return parts[0].clone(); } let mut result = String::new(); for (i, part) in parts.iter().enumerate() { if i > 0 { // 이전 part가 텍스트이고 현재 part도 텍스트인 경우: 스페이스 2개 + 개행 // If previous part is text and current part is also text: two spaces + newline if is_text_part(&parts[i - 1]) && is_text_part(part) { result.push_str(" \n"); } // 블록 요소가 포함된 경우: 빈 줄 // When block elements are involved, use blank line else { result.push_str("\n\n"); } } result.push_str(part); } result }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/viewer/markdown/document/bodytext/para_text.rs	crates/hwp-core/src/viewer/markdown/document/bodytext/para_text.rs	/// ParaText conversion to Markdown /// ParaText를 마크다운으로 변환하는 모듈 /// /// 스펙 문서 매핑: 표 57 - 본문의 데이터 레코드, PARA_TEXT (HWPTAG_BEGIN + 51) /// Spec mapping: Table 57 - BodyText data records, PARA_TEXT (HWPTAG_BEGIN + 51) use crate::document::bodytext::{CharShapeInfo, ControlChar, ControlCharPosition}; use crate::document::CharShape; /// 의미 있는 텍스트인지 확인합니다. / Check if text is meaningful. /// /// 공백만 있는 텍스트는 의미 없다고 판단합니다. /// Text containing only whitespace is considered meaningless. /// /// # Arguments / 매개변수 /// * `text` - 제어 문자가 이미 제거된 텍스트 / Text with control characters already removed /// * `control_positions` - 제어 문자 위치 정보 (현재는 사용되지 않음) / Control character positions (currently unused) /// /// # Returns / 반환값 /// 의미 있는 텍스트이면 `true`, 그렇지 않으면 `false` / `true` if meaningful, `false` otherwise /// /// # Note /// 제어 문자는 이미 파싱 단계에서 text에서 제거되었으므로, /// 텍스트가 비어있지 않은지만 확인합니다. /// Control characters are already removed from text during parsing, /// so we only check if text is not empty. pub(crate) fn is_meaningful_text(text: &str, _control_positions: &[ControlCharPosition]) -> bool { !text.trim().is_empty() } /// Convert ParaText to markdown /// ParaText를 마크다운으로 변환 /// /// # Arguments / 매개변수 /// * `text` - 텍스트 내용 / Text content /// * `control_positions` - 제어 문자 위치 정보 / Control character positions /// /// # Returns / 반환값 /// 마크다운 문자열 / Markdown string /// Convert character index to byte index in UTF-8 string /// UTF-8 문자열에서 문자 인덱스를 바이트 인덱스로 변환 fn char_index_to_byte_index(text: &str, char_idx: usize) -> Option<usize> { text.char_indices() .nth(char_idx) .map(\|(byte_idx, _)\| byte_idx) } /// CharShape 정보를 사용하여 텍스트를 구간별로 나누고 마크다운 스타일을 적용 /// Divide text into segments by CharShape information and apply markdown styles fn convert_text_with_char_shapes<'a>( text: &str, control_positions: &[ControlCharPosition], char_shapes: &[CharShapeInfo], get_char_shape: &'a dyn Fn(u32) -> Option<&'a CharShape>, ) -> Option<String> { if text.trim().is_empty() { return None; } let text_chars: Vec<char> = text.chars().collect(); let text_len = text_chars.len(); // CharShape 정보를 position 기준으로 정렬 / Sort CharShape info by position let mut sorted_shapes: Vec<_> = char_shapes.iter().collect(); sorted_shapes.sort_by_key(\|shape\| shape.position); let mut result = String::new(); let mut segments: Vec<(usize, usize, Option<&CharShape>)> = Vec::new(); // 구간 정의 / Define segments let mut positions = vec![0]; for shape_info in &sorted_shapes { let pos = shape_info.position as usize; if pos <= text_len { positions.push(pos); } } positions.push(text_len); positions.sort(); positions.dedup(); // 각 구간에 대한 CharShape 찾기 / Find CharShape for each segment for i in 0..positions.len() - 1 { let start = positions[i]; let end = positions[i + 1]; // 이 구간에 적용할 CharShape 찾기 / Find CharShape to apply to this segment // start 위치에서 시작하는 가장 가까운 CharShape를 찾음 / Find the closest CharShape starting at start position let char_shape = sorted_shapes .iter() .find(\|shape\| (shape.position as usize) == start) .or_else(\|\| { // 정확히 일치하는 것이 없으면, start보다 작은 position 중 가장 큰 것을 찾음 // If no exact match, find the largest position less than start sorted_shapes .iter() .rev() .find(\|shape\| (shape.position as usize) < start) }) .and_then(\|shape\| get_char_shape(shape.shape_id)); segments.push((start, end, char_shape)); } // PARA_BREAK/LINE_BREAK 위치 수집 / Collect PARA_BREAK/LINE_BREAK positions let mut break_positions: Vec<usize> = control_positions .iter() .filter(\|pos\| pos.code == ControlChar::PARA_BREAK \|\| pos.code == ControlChar::LINE_BREAK) .map(\|pos\| usize::from(pos.position)) .collect(); break_positions.sort(); // 각 구간에 스타일 적용하여 결과 생성 / Generate result by applying styles to each segment for (start, end, char_shape) in &segments { if start < end && end <= text_len { // 이 구간 내에 PARA_BREAK/LINE_BREAK가 있는지 확인 / Check if there are breaks in this segment let mut segment_breaks: Vec<usize> = break_positions .iter() .filter(\|&&break_pos\| break_pos >= start && break_pos < end) .copied() .collect(); if segment_breaks.is_empty() { // 구간 내에 break가 없으면 전체 구간에 스타일 적용 / No breaks in segment, apply style to entire segment let segment_text: String = text_chars[start..end].iter().collect(); if !segment_text.trim().is_empty() { if let Some(shape) = char_shape { let styled = apply_markdown_styles( &segment_text, shape.attributes.bold, shape.attributes.italic, shape.attributes.strikethrough != 0, ); result.push_str(&styled); } else { result.push_str(&segment_text); } } } else { // 구간 내에 break가 있으면 break 위치로 나누어 처리 / Split segment by breaks segment_breaks.insert(0, start); segment_breaks.push(end); for i in 0..segment_breaks.len() - 1 { let seg_start = segment_breaks[i]; let seg_end = segment_breaks[i + 1]; if seg_start < seg_end && seg_end <= text_len { let segment_text: String = text_chars[seg_start..seg_end].iter().collect(); if !segment_text.trim().is_empty() { if let Some(shape) = char_shape { let styled = apply_markdown_styles( &segment_text, shape.attributes.bold, shape.attributes.italic, shape.attributes.strikethrough != 0, ); result.push_str(&styled); } else { result.push_str(&segment_text); } } } // break 다음이면 마크다운 개행 추가 / Add markdown line break after break if i < segment_breaks.len() - 2 { result.push_str(" \n"); } } } } } let trimmed_result = result.trim(); if !trimmed_result.is_empty() { Some(trimmed_result.to_string()) } else { None } } /// 텍스트에 마크다운 스타일을 적용합니다. / Apply markdown styles to text. /// /// # Arguments / 매개변수 /// `text` - 원본 텍스트 / Original text /// * `bold` - 진하게 여부 / Bold /// * `italic` - 기울임 여부 / Italic /// * `strikethrough` - 가운뎃줄 여부 / Strikethrough /// /// # Returns / 반환값 /// 마크다운 스타일이 적용된 텍스트 / Text with markdown styles applied fn apply_markdown_styles(text: &str, bold: bool, italic: bool, strikethrough: bool) -> String { if text.is_empty() { return String::new(); } let mut result = String::from(text); // 마크다운 스타일 적용 순서: strikethrough (가장 바깥) -> bold -> italic (가장 안쪽) // Markdown style application order: strikethrough (outermost) -> bold -> italic (innermost) // 기울임 적용 (가장 안쪽) / Apply italic (innermost) if italic { result = format!("{}", result); } // 진하게 적용 / Apply bold if bold { result = format!("{}", result); } // 가운뎃줄 적용 (가장 바깥쪽) / Apply strikethrough (outermost) if strikethrough { result = format!("~~{}~~", result); } result } pub fn convert_para_text_to_markdown( text: &str, control_positions: &[ControlCharPosition], ) -> Option<String> { convert_para_text_to_markdown_with_char_shapes(text, control_positions, &[], None) } /// CharShape 정보를 사용하여 ParaText를 마크다운으로 변환 /// Convert ParaText to markdown using CharShape information /// /// # Arguments / 매개변수 /// * `text` - 텍스트 내용 / Text content /// * `control_positions` - 제어 문자 위치 정보 / Control character positions /// * `char_shapes` - 글자 모양 정보 리스트 / Character shape information list /// * `get_char_shape` - shape_id로 CharShape를 가져오는 함수 / Function to get CharShape by shape_id /// /// # Returns / 반환값 /// 마크다운 문자열 / Markdown string pub fn convert_para_text_to_markdown_with_char_shapes<'a>( text: &str, control_positions: &[ControlCharPosition], char_shapes: &[CharShapeInfo], get_char_shape: Option<&'a dyn Fn(u32) -> Option<&'a CharShape>>, ) -> Option<String> { // CharShape 정보가 있으면 텍스트를 구간별로 나누어 스타일 적용 / If CharShape info exists, divide text into segments and apply styles if !char_shapes.is_empty() && get_char_shape.is_some() { return convert_text_with_char_shapes( text, control_positions, char_shapes, get_char_shape.unwrap(), ); } // PARA_BREAK나 LINE_BREAK가 있는지 확인 / Check for PARA_BREAK or LINE_BREAK let has_breaks = control_positions .iter() .any(\|pos\| pos.code == ControlChar::PARA_BREAK \|\| pos.code == ControlChar::LINE_BREAK); if !has_breaks { // 제어 문자가 없으면 기존 로직 사용 / Use existing logic if no control characters if is_meaningful_text(text, control_positions) { let trimmed = text.trim(); if !trimmed.is_empty() { return Some(trimmed.to_string()); } } return None; } // PARA_BREAK/LINE_BREAK가 있는 경우 처리 / Process when PARA_BREAK/LINE_BREAK exists // 파서에서 \n을 제거했으므로, control_positions의 정보만 사용하여 마크다운 개행으로 변환 // Parser removed \n, so only use control_positions info to convert to markdown line breaks let mut result = String::new(); let mut last_char_pos = 0; // control_positions를 정렬하여 순서대로 처리 / Sort control_positions to process in order let mut sorted_positions: Vec<_> = control_positions.iter().collect(); sorted_positions.sort_by_key(\|pos\| pos.position); for pos in sorted_positions { // PARA_BREAK나 LINE_BREAK만 처리 / Only process PARA_BREAK or LINE_BREAK if pos.code != ControlChar::PARA_BREAK && pos.code != ControlChar::LINE_BREAK { continue; } // 문자 인덱스를 바이트 인덱스로 변환 / Convert character index to byte index let byte_idx = match char_index_to_byte_index(text, pos.position) { Some(idx) => idx, None => continue, // 유효하지 않은 위치는 건너뜀 / Skip invalid position }; let last_byte_idx = char_index_to_byte_index(text, last_char_pos).unwrap_or(0); // 제어 문자 이전의 텍스트 추가 (파서에서 \n이 제거되었으므로 그대로 사용) // Add text before control character (parser removed \n, so use as-is) if byte_idx > last_byte_idx && byte_idx <= text.len() { let text_part = &text[last_byte_idx..byte_idx]; let trimmed = text_part.trim(); if !trimmed.is_empty() { result.push_str(trimmed); } } // PARA_BREAK나 LINE_BREAK를 마크다운 개행(스페이스 2개 + 개행)으로 변환 // Convert PARA_BREAK or LINE_BREAK to markdown line break (two spaces + newline) result.push_str(" \n"); // 제어 문자 다음 위치 / Position after control character last_char_pos = pos.position + 1; } // 마지막 부분의 텍스트 추가 / Add remaining text let last_byte_idx = char_index_to_byte_index(text, last_char_pos).unwrap_or(0); if last_byte_idx < text.len() { let text_part = &text[last_byte_idx..]; let trimmed = text_part.trim(); if !trimmed.is_empty() { result.push_str(trimmed); } } // trim() 대신 trim_start()만 사용하여 줄 끝 공백(마크다운 개행용)은 유지 // Use trim_start() instead of trim() to preserve trailing spaces (for markdown line breaks) let trimmed_result = result.trim_start(); if !trimmed_result.is_empty() { Some(trimmed_result.to_string()) } else { None } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/preview_image.rs	crates/hwp-core/src/document/preview_image.rs	/// PreviewImage 구조체 / PreviewImage structure /// /// 스펙 문서 매핑: 3.2.7 - 미리보기 이미지 / Spec mapping: 3.2.7 - Preview image /// /// `PrvImage` 스트림에는 미리보기 이미지가 BMP 또는 GIF 형식으로 저장됩니다. /// The `PrvImage` stream contains preview image stored as BMP or GIF format. use crate::error::HwpError; use base64::{engine::general_purpose::STANDARD, Engine as _}; use serde::{Deserialize, Serialize}; use std::path::Path; /// 미리보기 이미지 / Preview image #[derive(Debug, Clone, Serialize, Deserialize)] pub struct PreviewImage { /// Base64로 인코딩된 이미지 데이터 / Base64 encoded image data pub data: String, /// 이미지 형식 ("BMP" 또는 "GIF") / Image format ("BMP" or "GIF") pub format: String, /// 파일로 저장된 경우 파일 경로 (선택적) / File path if saved as file (optional) #[serde(skip_serializing_if = "Option::is_none")] pub file_path: Option<String>, } impl PreviewImage { /// PreviewImage를 바이트 배열에서 파싱합니다. / Parse PreviewImage from byte array. /// /// # Arguments /// * `data` - PrvImage 스트림의 원시 바이트 데이터 / Raw byte data of PrvImage stream /// * `save_to_file` - 파일로 저장할 디렉토리 경로 (선택적) / Optional directory path to save file /// /// # Returns /// 파싱된 PreviewImage 구조체 / Parsed PreviewImage structure /// /// # Note /// 스펙 문서 3.2.7에 따르면 PrvImage 스트림에는 미리보기 이미지가 BMP 또는 GIF 형식으로 저장됩니다. /// According to spec 3.2.7, the PrvImage stream contains preview image stored as BMP or GIF format. /// 이미지 형식은 파일 시그니처를 확인하여 감지합니다. /// Image format is detected by checking file signature. /// 이미지 데이터는 항상 base64로 인코딩되어 저장되며, 선택적으로 파일로도 저장할 수 있습니다. /// Image data is always stored as base64 encoded string, and optionally saved as file. pub fn parse(data: &[u8], save_to_file: Option<&str>) -> Result<Self, HwpError> { if data.is_empty() { return Err(HwpError::InsufficientData { field: "PreviewImage data".to_string(), expected: 1, actual: 0, }); } // 이미지 형식 감지 / Detect image format // BMP: "BM" (0x42 0x4D)로 시작 / BMP: starts with "BM" (0x42 0x4D) // GIF: "GIF87a" 또는 "GIF89a"로 시작 / GIF: starts with "GIF87a" or "GIF89a" let format = if data.len() >= 2 && data[0] == 0x42 && data[1] == 0x4D { "BMP".to_string() } else if data.len() >= 6 { let gif_header = &data[0..6]; if gif_header == b"GIF87a" \|\| gif_header == b"GIF89a" { "GIF".to_string() } else { // 알 수 없는 형식이지만 데이터는 저장 / Unknown format but store data "UNKNOWN".to_string() } } else { // 데이터가 너무 짧아서 형식을 확인할 수 없음 / Data too short to determine format "UNKNOWN".to_string() }; // Base64 인코딩 / Base64 encoding let base64_data = STANDARD.encode(data); // 파일로 저장 (선택적) / Save to file (optional) let file_path = if let Some(dir_path) = save_to_file { let extension = match format.as_str() { "BMP" => "bmp", "GIF" => "gif", _ => "bin", }; let file_name = format!("preview_image.{}", extension); let file_path = Path::new(dir_path).join(&file_name); std::fs::create_dir_all(dir_path).map_err(\|e\| { HwpError::Io(format!("Failed to create directory '{}': {}", dir_path, e)) })?; std::fs::write(&file_path, data).map_err(\|e\| { HwpError::Io(format!( "Failed to write preview image file '{}': {}", file_path.display(), e )) })?; Some(file_path.to_string_lossy().to_string()) } else { None }; Ok(PreviewImage { data: base64_data, format, file_path, }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/preview_text.rs	crates/hwp-core/src/document/preview_text.rs	/// PreviewText 구조체 / PreviewText structure /// /// 스펙 문서 매핑: 3.2.6 - 미리보기 텍스트 / Spec mapping: 3.2.6 - Preview text /// /// `PrvText` 스트림에는 미리보기 텍스트가 유니코드 문자열로 저장됩니다. /// The `PrvText` stream contains preview text stored as Unicode string. use crate::error::HwpError; use crate::types::decode_utf16le; use serde::{Deserialize, Serialize}; /// 미리보기 텍스트 / Preview text #[derive(Debug, Clone, Serialize, Deserialize)] pub struct PreviewText { /// 미리보기 텍스트 내용 (UTF-16LE) / Preview text content (UTF-16LE) pub text: String, } impl PreviewText { /// PreviewText를 바이트 배열에서 파싱합니다. / Parse PreviewText from byte array. /// /// # Arguments /// * `data` - PrvText 스트림의 원시 바이트 데이터 / Raw byte data of PrvText stream /// /// # Returns /// 파싱된 PreviewText 구조체 / Parsed PreviewText structure /// /// # Note /// 스펙 문서 3.2.6에 따르면 PrvText 스트림에는 미리보기 텍스트가 유니코드 문자열로 저장됩니다. /// According to spec 3.2.6, the PrvText stream contains preview text stored as Unicode string. /// UTF-16LE 형식으로 저장되므로 decode_utf16le 함수를 사용하여 디코딩합니다. /// Since it's stored in UTF-16LE format, we use decode_utf16le function to decode it. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // UTF-16LE 디코딩 / Decode UTF-16LE let text = decode_utf16le(data) .map_err(\|e\| HwpError::EncodingError { reason: format!("Failed to decode preview text: {}", e), })?; Ok(PreviewText { text }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/xml_template.rs	crates/hwp-core/src/document/xml_template.rs	/// XmlTemplate 구조체 / XmlTemplate structure /// /// 스펙 문서 매핑: 3.2.10 - XML 템플릿 / Spec mapping: 3.2.10 - XML Template /// /// `XMLTemplate` 스토리지에는 XML Template 정보가 저장됩니다. /// The `XMLTemplate` storage contains XML Template information. use crate::cfb::CfbParser; use crate::error::HwpError; use crate::types::{decode_utf16le, DWORD}; use serde::{Deserialize, Serialize}; /// XML 템플릿 / XML Template #[derive(Debug, Clone, Default, Serialize, Deserialize)] pub struct XmlTemplate { /// Schema 이름 (from _SchemaName stream) / Schema name (from _SchemaName stream) #[serde(skip_serializing_if = "Option::is_none")] pub schema_name: Option<String>, /// Schema (from Schema stream) / Schema (from Schema stream) #[serde(skip_serializing_if = "Option::is_none")] pub schema: Option<String>, /// Instance (from Instance stream) / Instance (from Instance stream) #[serde(skip_serializing_if = "Option::is_none")] pub instance: Option<String>, } impl XmlTemplate { /// XmlTemplate을 CFB 구조에서 파싱합니다. / Parse XmlTemplate from CFB structure. /// /// # Arguments /// * `cfb` - CompoundFile structure (mutable reference required) / CompoundFile 구조체 (가변 참조 필요) /// /// # Returns /// 파싱된 XmlTemplate 구조체 / Parsed XmlTemplate structure /// /// # Note /// 스펙 문서 3.2.10에 따르면 XMLTemplate 스토리지에는 다음 스트림이 포함됩니다: /// - _SchemaName: Schema 이름 (표 10) /// - Schema: Schema 문자열 (표 11) /// - Instance: Instance 문자열 (표 12) /// According to spec 3.2.10, XMLTemplate storage contains the following streams: /// - _SchemaName: Schema name (Table 10) /// - Schema: Schema string (Table 11) /// - Instance: Instance string (Table 12) pub fn parse(cfb: &mut cfb::CompoundFile<std::io::Cursor<&[u8]>>) -> Result<Self, HwpError> { let mut xml_template = XmlTemplate::default(); // Parse _SchemaName stream // _SchemaName 스트림 파싱 / Parse _SchemaName stream // 스펙 문서 표 10: Schema 이름 정보 // Spec Table 10: Schema name information if let Ok(schema_name_data) = CfbParser::read_nested_stream(cfb, "XMLTemplate", "_SchemaName") { match Self::parse_schema_name(&schema_name_data) { Ok(schema_name) => { xml_template.schema_name = Some(schema_name); } Err(e) => { #[cfg(debug_assertions)] eprintln!("Warning: Failed to parse _SchemaName stream: {}", e); } } } // Parse Schema stream // Schema 스트림 파싱 / Parse Schema stream // 스펙 문서 표 11: Schema 길이 정보 // Spec Table 11: Schema length information if let Ok(schema_data) = CfbParser::read_nested_stream(cfb, "XMLTemplate", "Schema") { match Self::parse_schema(&schema_data) { Ok(schema) => { xml_template.schema = Some(schema); } Err(e) => { #[cfg(debug_assertions)] eprintln!("Warning: Failed to parse Schema stream: {}", e); } } } // Parse Instance stream // Instance 스트림 파싱 / Parse Instance stream // 스펙 문서 표 12: Instance 정보 // Spec Table 12: Instance information if let Ok(instance_data) = CfbParser::read_nested_stream(cfb, "XMLTemplate", "Instance") { match Self::parse_instance(&instance_data) { Ok(instance) => { xml_template.instance = Some(instance); } Err(e) => { #[cfg(debug_assertions)] eprintln!("Warning: Failed to parse Instance stream: {}", e); } } } Ok(xml_template) } /// Schema 이름 파싱 (표 10) / Parse schema name (Table 10) fn parse_schema_name(data: &[u8]) -> Result<String, HwpError> { if data.len() < 4 { return Err(HwpError::insufficient_data( "Schema name data", 4, data.len(), )); } // DWORD Schema 이름 길이 (4 bytes) / Schema name length (4 bytes) let len = DWORD::from_le_bytes([data[0], data[1], data[2], data[3]]) as usize; // WCHAR array[len] Schema 이름 (2×len bytes) / Schema name (2×len bytes) if data.len() < 4 + (len * 2) { return Err(HwpError::InsufficientData { field: "Schema name data".to_string(), expected: 4 + (len * 2), actual: data.len(), }); } if len > 0 { let schema_name_bytes = &data[4..4 + (len * 2)]; decode_utf16le(schema_name_bytes).map_err(\|e\| HwpError::EncodingError { reason: format!("Failed to decode schema name: {}", e), }) } else { Ok(String::new()) } } /// Schema 파싱 (표 11) / Parse schema (Table 11) fn parse_schema(data: &[u8]) -> Result<String, HwpError> { if data.len() < 4 { return Err(HwpError::insufficient_data("Schema data", 4, data.len())); } // DWORD Schema 길이 (4 bytes) / Schema length (4 bytes) let len = DWORD::from_le_bytes([data[0], data[1], data[2], data[3]]) as usize; // WCHAR array[len] Schema (2×len bytes) / Schema (2×len bytes) if data.len() < 4 + (len * 2) { return Err(HwpError::InsufficientData { field: "Schema data".to_string(), expected: 4 + (len * 2), actual: data.len(), }); } if len > 0 { let schema_bytes = &data[4..4 + (len * 2)]; decode_utf16le(schema_bytes).map_err(\|e\| HwpError::EncodingError { reason: format!("Failed to decode schema: {}", e), }) } else { Ok(String::new()) } } /// Instance 파싱 (표 12) / Parse instance (Table 12) fn parse_instance(data: &[u8]) -> Result<String, HwpError> { if data.len() < 4 { return Err(HwpError::insufficient_data("Instance data", 4, data.len())); } // DWORD Instance 길이 (4 bytes) / Instance length (4 bytes) let len = DWORD::from_le_bytes([data[0], data[1], data[2], data[3]]) as usize; // WCHAR array[len] Instance (2×len bytes) / Instance (2×len bytes) if data.len() < 4 + (len * 2) { return Err(HwpError::InsufficientData { field: "Instance data".to_string(), expected: 4 + (len * 2), actual: data.len(), }); } if len > 0 { let instance_bytes = &data[4..4 + (len * 2)]; decode_utf16le(instance_bytes).map_err(\|e\| HwpError::EncodingError { reason: format!("Failed to decode instance: {}", e), }) } else { Ok(String::new()) } } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/mod.rs	crates/hwp-core/src/document/mod.rs	pub mod bindata; pub mod bodytext; pub mod constants; pub mod docinfo; /// HWP Document structure /// /// This module defines the main document structure for HWP files. /// /// 스펙 문서 매핑: 표 2 - 전체 구조 pub mod fileheader; pub mod preview_image; pub mod preview_text; pub mod scripts; pub mod summary_information; pub mod xml_template; pub use bindata::{BinData, BinaryDataFormat}; pub use bodytext::{ BodyText, ColumnDivideType, CtrlHeader, CtrlHeaderData, CtrlId, PageNumberPosition, Paragraph, ParagraphRecord, Section, }; pub use docinfo::{ BinDataRecord, BorderFill, Bullet, CharShape, DocInfo, DocumentProperties, FaceName, FillInfo, HeaderShapeType, IdMappings, Numbering, ParaShape, Style, TabDef, }; pub use fileheader::FileHeader; pub use preview_image::PreviewImage; pub use preview_text::PreviewText; pub use scripts::Scripts; pub use summary_information::SummaryInformation; pub use xml_template::XmlTemplate; use serde::{Deserialize, Serialize}; /// Main HWP document structure #[derive(Debug, Clone, Serialize, Deserialize)] pub struct HwpDocument { /// File header information pub file_header: FileHeader, /// Document information (DocInfo stream) pub doc_info: DocInfo, /// Body text (BodyText storage) pub body_text: BodyText, /// Binary data (BinData storage) pub bin_data: BinData, /// Preview text (PrvText stream) pub preview_text: Option<PreviewText>, /// Preview image (PrvImage stream) pub preview_image: Option<PreviewImage>, /// Scripts (Scripts storage) pub scripts: Option<Scripts>, /// XML Template (XMLTemplate storage) pub xml_template: Option<XmlTemplate>, /// Summary Information (\005HwpSummaryInformation stream) pub summary_information: Option<SummaryInformation>, } impl HwpDocument { /// Create a new empty HWP document pub fn new(file_header: FileHeader) -> Self { Self { file_header, doc_info: DocInfo::default(), body_text: BodyText::default(), bin_data: BinData::default(), preview_text: None, preview_image: None, scripts: None, xml_template: None, summary_information: None, } } /// Convert HWP document to Markdown format /// HWP 문서를 마크다운 형식으로 변환 /// /// # Arguments / 매개변수 /// * `options` - Markdown conversion options / 마크다운 변환 옵션 /// /// # Returns / 반환값 /// Markdown string representation of the document / 문서의 마크다운 문자열 표현 pub fn to_markdown(&self, options: &crate::viewer::markdown::MarkdownOptions) -> String { crate::viewer::to_markdown(self, options) } /// Convert HWP document to Markdown format (기존 API 호환성) /// HWP 문서를 마크다운 형식으로 변환 (기존 API 호환성) /// /// # Arguments / 매개변수 /// * `image_output_dir` - Optional directory path to save images as files. If None, images are embedded as base64 data URIs. /// 이미지를 파일로 저장할 디렉토리 경로 (선택). None이면 base64 데이터 URI로 임베드됩니다. /// /// # Returns / 반환값 /// Markdown string representation of the document / 문서의 마크다운 문자열 표현 pub fn to_markdown_with_dir(&self, image_output_dir: Option<&str>) -> String { let options = crate::viewer::markdown::MarkdownOptions { image_output_dir: image_output_dir.map(\|s\| s.to_string()), use_html: Some(true), include_version: Some(true), include_page_info: Some(true), }; crate::viewer::to_markdown(self, &options) } /// Convert HWP document to HTML format /// HWP 문서를 HTML 형식으로 변환 /// /// # Arguments / 매개변수 /// * `options` - HTML conversion options / HTML 변환 옵션 /// /// # Returns / 반환값 /// HTML string representation of the document / 문서의 HTML 문자열 표현 pub fn to_html(&self, options: &crate::viewer::html::HtmlOptions) -> String { crate::viewer::to_html(self, options) } /// Resolve derived display texts for control tokens (e.g., AUTO_NUMBER) into `ParaTextRun::Control.display_text`. /// /// IMPORTANT: /// - `runs` (control tokens + document settings) are the source of truth. /// - `display_text` is a derived/cache value for preview/viewers and may be recomputed. pub fn resolve_display_texts(&mut self) { use crate::document::bodytext::{ControlChar, ParaTextRun}; use crate::document::ParagraphRecord; // Footnote/endnote numbering rules are defined by FootnoteShape (spec Table 133/134). // In practice, two FootnoteShape records appear (footnote, endnote). If only one exists, // we reuse it for both. let mut footnote_shape_opt: Option<crate::document::bodytext::FootnoteShape> = None; let mut endnote_shape_opt: Option<crate::document::bodytext::FootnoteShape> = None; for section in &self.body_text.sections { for paragraph in &section.paragraphs { for record in &paragraph.records { if let ParagraphRecord::FootnoteShape { footnote_shape } = record { if footnote_shape_opt.is_none() { footnote_shape_opt = Some(footnote_shape.clone()); } else if endnote_shape_opt.is_none() { endnote_shape_opt = Some(footnote_shape.clone()); } } } } } if endnote_shape_opt.is_none() { endnote_shape_opt = footnote_shape_opt.clone(); } let mut table_no: u32 = self .doc_info .document_properties .as_ref() .map(\|p\| p.table_start_number as u32) .unwrap_or(1); let footnote_start: u32 = footnote_shape_opt .as_ref() .map(\|s\| s.start_number as u32) .or_else(\|\| { self.doc_info .document_properties .as_ref() .map(\|p\| p.footnote_start_number as u32) }) .unwrap_or(1); let endnote_start: u32 = endnote_shape_opt .as_ref() .map(\|s\| s.start_number as u32) .or_else(\|\| { self.doc_info .document_properties .as_ref() .map(\|p\| p.endnote_start_number as u32) }) .unwrap_or(1); let footnote_numbering = footnote_shape_opt .as_ref() .map(\|s\| s.attributes.numbering) .unwrap_or(crate::document::bodytext::footnote_shape::NumberingMethod::Continue); let endnote_numbering = endnote_shape_opt .as_ref() .map(\|s\| s.attributes.numbering) .unwrap_or(crate::document::bodytext::footnote_shape::NumberingMethod::Continue); // NOTE: PerPage is currently treated the same as Continue (requested). let mut footnote_no: u32 = footnote_start; let mut endnote_no: u32 = endnote_start; let mut image_no: u32 = self .doc_info .document_properties .as_ref() .map(\|p\| p.image_start_number as u32) .unwrap_or(1); let mut formula_no: u32 = self .doc_info .document_properties .as_ref() .map(\|p\| p.formula_start_number as u32) .unwrap_or(1); #[derive(Debug, Clone, Copy, PartialEq, Eq)] enum AutoNumberKind { Page = 0, Footnote = 1, Endnote = 2, Image = 3, Table = 4, Formula = 5, Unknown = 255, } fn parse_auto_number_kind(attribute: u32) -> AutoNumberKind { match (attribute & 0x0F) as u8 { 0 => AutoNumberKind::Page, 1 => AutoNumberKind::Footnote, 2 => AutoNumberKind::Endnote, 3 => AutoNumberKind::Image, 4 => AutoNumberKind::Table, 5 => AutoNumberKind::Formula, _ => AutoNumberKind::Unknown, } } fn parse_number_shape( attribute: u32, ) -> crate::document::bodytext::footnote_shape::NumberShape { // spec Table 143 bit 4-11 number shape, mapping uses Table 134 (same as FootnoteShape) let v = ((attribute >> 4) & 0xFF) as u8; use crate::document::bodytext::footnote_shape::NumberShape; match v { 0 => NumberShape::Arabic, 1 => NumberShape::CircledArabic, 2 => NumberShape::RomanUpper, 3 => NumberShape::RomanLower, 4 => NumberShape::AlphaUpper, 5 => NumberShape::AlphaLower, 6 => NumberShape::CircledAlphaUpper, 7 => NumberShape::CircledAlphaLower, 8 => NumberShape::Hangul, 9 => NumberShape::CircledHangul, 10 => NumberShape::HangulJamo, 11 => NumberShape::CircledHangulJamo, 12 => NumberShape::HangulNumber, 13 => NumberShape::ChineseNumber, 14 => NumberShape::CircledChineseNumber, 15 => NumberShape::HeavenlyStem, 16 => NumberShape::HeavenlyStemChinese, 0x80 => NumberShape::FourCharRepeat, 0x81 => NumberShape::CustomCharRepeat, _ => NumberShape::Arabic, } } fn format_number( shape: crate::document::bodytext::footnote_shape::NumberShape, n: u32, ) -> String { use crate::document::bodytext::footnote_shape::NumberShape; match shape { NumberShape::Arabic => n.to_string(), NumberShape::RomanUpper => to_roman(n).to_uppercase(), NumberShape::RomanLower => to_roman(n).to_lowercase(), NumberShape::AlphaUpper => to_alpha(n, true), NumberShape::AlphaLower => to_alpha(n, false), NumberShape::CircledArabic => circled_number(n).unwrap_or_else(\|\| n.to_string()), NumberShape::CircledAlphaUpper => { circled_alpha(n, true).unwrap_or_else(\|\| to_alpha(n, true)) } NumberShape::CircledAlphaLower => { circled_alpha(n, false).unwrap_or_else(\|\| to_alpha(n, false)) } NumberShape::Hangul => hangul_gana(n).unwrap_or_else(\|\| n.to_string()), NumberShape::HangulJamo => hangul_jamo(n).unwrap_or_else(\|\| n.to_string()), NumberShape::CircledHangul => circled_hangul_gana(n) .unwrap_or_else(\|\| hangul_gana(n).unwrap_or_else(\|\| n.to_string())), NumberShape::CircledHangulJamo => circled_hangul_jamo(n) .unwrap_or_else(\|\| hangul_jamo(n).unwrap_or_else(\|\| n.to_string())), NumberShape::HangulNumber => hangul_number(n).unwrap_or_else(\|\| n.to_string()), NumberShape::ChineseNumber => chinese_number(n).unwrap_or_else(\|\| n.to_string()), NumberShape::CircledChineseNumber => circled_chinese_number(n) .unwrap_or_else(\|\| chinese_number(n).unwrap_or_else(\|\| n.to_string())), NumberShape::HeavenlyStem => heavenly_stem(n).unwrap_or_else(\|\| n.to_string()), NumberShape::HeavenlyStemChinese => { heavenly_stem_chinese(n).unwrap_or_else(\|\| n.to_string()) } // NOTE: Repeat-based shapes require additional spec-backed inputs (e.g., custom symbol set). // We intentionally fall back to Arabic until we can resolve the exact behavior from spec/fixtures. NumberShape::FourCharRepeat \| NumberShape::CustomCharRepeat => n.to_string(), } } fn circled_number(n: u32) -> Option<String> { // ①..⑳ (U+2460..U+2473) for 1..20 if (1..=20).contains(&n) { let cp = 0x2460 + (n - 1); return char::from_u32(cp).map(\|c\| c.to_string()); } // ㉑..㉟ (U+3251..U+325F) for 21..35 (circled numbers in a circle) if (21..=35).contains(&n) { let cp = 0x3251 + (n - 21); return char::from_u32(cp).map(\|c\| c.to_string()); } None } fn circled_alpha(n: u32, upper: bool) -> Option<String> { // Ⓐ..Ⓩ (U+24B6..U+24CF) for 1..26 // ⓐ..ⓩ (U+24D0..U+24E9) for 1..26 if !(1..=26).contains(&n) { return None; } let base = if upper { 0x24B6 } else { 0x24D0 }; let cp = base + (n - 1); char::from_u32(cp).map(\|c\| c.to_string()) } fn hangul_gana(n: u32) -> Option<String> { // 가..하 (14 chars) used commonly for numbering const LIST: [&str; 14] = [ "가", "나", "다", "라", "마", "바", "사", "아", "자", "차", "카", "타", "파", "하", ]; if n == 0 { return None; } let idx = ((n - 1) % (LIST.len() as u32)) as usize; Some(LIST[idx].to_string()) } fn circled_hangul_gana(n: u32) -> Option<String> { // ㉮..㉻ (U+326E..U+327B) for 1..14 if !(1..=14).contains(&n) { return None; } let cp = 0x326E + (n - 1); char::from_u32(cp).map(\|c\| c.to_string()) } fn hangul_jamo(n: u32) -> Option<String> { // ㄱ ㄴ ㄷ ㄹ ㅁ ㅂ ㅅ ㅇ ㅈ ㅊ ㅋ ㅌ ㅍ ㅎ const LIST: [&str; 14] = [ "ㄱ", "ㄴ", "ㄷ", "ㄹ", "ㅁ", "ㅂ", "ㅅ", "ㅇ", "ㅈ", "ㅊ", "ㅋ", "ㅌ", "ㅍ", "ㅎ", ]; if n == 0 { return None; } let idx = ((n - 1) % (LIST.len() as u32)) as usize; Some(LIST[idx].to_string()) } fn circled_hangul_jamo(n: u32) -> Option<String> { // ㉠..㉭ (U+3260..U+326D) for 1..14 if !(1..=14).contains(&n) { return None; } let cp = 0x3260 + (n - 1); char::from_u32(cp).map(\|c\| c.to_string()) } fn hangul_number(n: u32) -> Option<String> { // 일, 이, 삼 ... (up to 99 for now) if n == 0 \|\| n > 99 { return None; } const DIGITS: [&str; 10] = ["", "일", "이", "삼", "사", "오", "육", "칠", "팔", "구"]; if n < 10 { return Some(DIGITS[n as usize].to_string()); } if n == 10 { return Some("십".to_string()); } let tens = n / 10; let ones = n % 10; let mut out = String::new(); if tens > 1 { out.push_str(DIGITS[tens as usize]); } out.push('십'); if ones > 0 { out.push_str(DIGITS[ones as usize]); } Some(out) } fn chinese_number(n: u32) -> Option<String> { // 一, 二, 三 ... (up to 99 for now) if n == 0 \|\| n > 99 { return None; } const DIGITS: [&str; 10] = ["", "一", "二", "三", "四", "五", "六", "七", "八", "九"]; if n < 10 { return Some(DIGITS[n as usize].to_string()); } if n == 10 { return Some("十".to_string()); } let tens = n / 10; let ones = n % 10; let mut out = String::new(); if tens > 1 { out.push_str(DIGITS[tens as usize]); } out.push('十'); if ones > 0 { out.push_str(DIGITS[ones as usize]); } Some(out) } fn circled_chinese_number(n: u32) -> Option<String> { // ㊀..㊉ (U+3280..U+3289) for 1..10 if !(1..=10).contains(&n) { return None; } let cp = 0x3280 + (n - 1); char::from_u32(cp).map(\|c\| c.to_string()) } fn heavenly_stem(n: u32) -> Option<String> { // 갑, 을, 병, 정, 무, 기, 경, 신, 임, 계 const LIST: [&str; 10] = ["갑", "을", "병", "정", "무", "기", "경", "신", "임", "계"]; if n == 0 { return None; } let idx = ((n - 1) % 10) as usize; Some(LIST[idx].to_string()) } fn heavenly_stem_chinese(n: u32) -> Option<String> { // 甲, 乙, 丙, 丁, 戊, 己, 庚, 辛, 壬, 癸 const LIST: [&str; 10] = ["甲", "乙", "丙", "丁", "戊", "己", "庚", "辛", "壬", "癸"]; if n == 0 { return None; } let idx = ((n - 1) % 10) as usize; Some(LIST[idx].to_string()) } fn to_roman(mut n: u32) -> String { if n == 0 { return String::new(); } let mut out = String::new(); let pairs = [ (1000, "M"), (900, "CM"), (500, "D"), (400, "CD"), (100, "C"), (90, "XC"), (50, "L"), (40, "XL"), (10, "X"), (9, "IX"), (5, "V"), (4, "IV"), (1, "I"), ]; for (v, s) in pairs { while n >= v { out.push_str(s); n -= v; } } out } fn to_alpha(mut n: u32, upper: bool) -> String { // 1->A, 26->Z, 27->AA if n == 0 { return String::new(); } let mut buf: Vec<u8> = Vec::new(); while n > 0 { n -= 1; let c = (n % 26) as u8; buf.push(if upper { b'A' + c } else { b'a' + c }); n /= 26; } buf.reverse(); String::from_utf8_lossy(&buf).to_string() } fn resolve_paragraph_record( record: &mut ParagraphRecord, table_no: &mut u32, footnote_no: &mut u32, endnote_no: &mut u32, _image_no: &mut u32, _formula_no: &mut u32, ) { match record { ParagraphRecord::CtrlHeader { header, children, paragraphs, .. } => { // Footnote/endnote ctrl headers ("fn " / "en "): assign number to all AUTO_NUMBER tokens in this subtree. if header.ctrl_id == "fn " \|\| header.ctrl_id == "en " { let current = if header.ctrl_id == "fn " { footnote_no } else { endnote_no }; fn fill_auto_numbers_in_records( records: &mut [ParagraphRecord], value: u32, ) { for r in records.iter_mut() { match r { ParagraphRecord::ParaText { runs, .. } => { for run in runs.iter_mut() { if let ParaTextRun::Control { code, display_text, .. } = run { if code == ControlChar::AUTO_NUMBER && display_text.is_none() { display_text = Some(value.to_string()); } } } } ParagraphRecord::CtrlHeader { children, paragraphs, .. } => { fill_auto_numbers_in_records(children, value); for p in paragraphs.iter_mut() { fill_auto_numbers_in_records(&mut p.records, value); } } ParagraphRecord::ListHeader { paragraphs, .. } => { for p in paragraphs.iter_mut() { fill_auto_numbers_in_records(&mut p.records, value); } } ParagraphRecord::ShapeComponent { children, .. } => { fill_auto_numbers_in_records(children, value); } _ => {} } } } fill_auto_numbers_in_records(children, current); for p in paragraphs.iter_mut() { fill_auto_numbers_in_records(&mut p.records, current); } if header.ctrl_id == "fn " { footnote_no += 1; } else { endnote_no += 1; } } // Table ctrl header ("tbl "): assign table number to the first AUTO_NUMBER found in caption paragraphs. if header.ctrl_id == "tbl " { let mut assigned_for_this_table = false; for p in paragraphs.iter_mut() { for r in p.records.iter_mut() { if let ParagraphRecord::ParaText { runs, .. } = r { for run in runs.iter_mut() { if let ParaTextRun::Control { code, display_text, .. } = run { if code == ControlChar::AUTO_NUMBER && display_text.is_none() { display_text = Some(table_no.to_string()); assigned_for_this_table = true; break; } } } } if assigned_for_this_table { break; } } if assigned_for_this_table { break; } } if assigned_for_this_table { table_no += 1; } } // Recurse into nested structures for completeness. for c in children.iter_mut() { resolve_paragraph_record( c, table_no, footnote_no, endnote_no, _image_no, _formula_no, ); } for p in paragraphs.iter_mut() { for r in p.records.iter_mut() { resolve_paragraph_record( r, table_no, footnote_no, endnote_no, _image_no, _formula_no, ); } } } ParagraphRecord::ListHeader { paragraphs, .. } => { for p in paragraphs.iter_mut() { for r in p.records.iter_mut() { resolve_paragraph_record( r, table_no, footnote_no, endnote_no, _image_no, _formula_no, ); } } } ParagraphRecord::ShapeComponent { children, .. } => { for c in children.iter_mut() { resolve_paragraph_record( c, table_no, footnote_no, endnote_no, _image_no, _formula_no, ); } } _ => {} } } for section in self.body_text.sections.iter_mut() { // Apply "Restart" per section. PerPage is currently treated as Continue. use crate::document::bodytext::footnote_shape::NumberingMethod; if matches!(footnote_numbering, NumberingMethod::Restart) { footnote_no = footnote_start; } if matches!(endnote_numbering, NumberingMethod::Restart) { endnote_no = endnote_start; } for paragraph in section.paragraphs.iter_mut() { // If this paragraph has an AutoNumber/NewNumber ctrl header, use it to resolve AUTO_NUMBER tokens in its ParaText runs. let mut para_auto_attr: Option<u32> = None; let mut para_auto_prefix: Option<String> = None; let mut para_auto_suffix: Option<String> = None; let mut new_number_attr_and_value: Option<(u32, u16)> = None; for record in paragraph.records.iter() { if let ParagraphRecord::CtrlHeader { header, .. } = record { match &header.data { crate::document::bodytext::ctrl_header::CtrlHeaderData::AutoNumber { attribute, prefix, suffix, .. } => { para_auto_attr = Some(attribute); if !prefix.is_empty() { para_auto_prefix = Some(prefix.clone()); } if !suffix.is_empty() { para_auto_suffix = Some(suffix.clone()); } } crate::document::bodytext::ctrl_header::CtrlHeaderData::NewNumber { attribute, number, } => { new_number_attr_and_value = Some((attribute, number)); } _ => {} } } } // Apply NEW_NUMBER to counters (bit 0-3: kind, number: new value) if let Some((attr, num)) = new_number_attr_and_value { match parse_auto_number_kind(attr) { AutoNumberKind::Footnote => footnote_no = num as u32, AutoNumberKind::Endnote => endnote_no = num as u32, AutoNumberKind::Image => image_no = num as u32, AutoNumberKind::Table => table_no = num as u32, AutoNumberKind::Formula => formula_no = num as u32, _ => {} } } // Fill AUTO_NUMBER tokens in this paragraph if we know the kind. if let Some(attr) = para_auto_attr { let kind = parse_auto_number_kind(attr); let shape = parse_number_shape(attr); let prefix = para_auto_prefix.as_deref().unwrap_or(""); let suffix = para_auto_suffix.as_deref().unwrap_or(""); let next_value = match kind { AutoNumberKind::Footnote => Some(footnote_no), AutoNumberKind::Endnote => Some(endnote_no), AutoNumberKind::Image => Some(image_no), AutoNumberKind::Table => Some(table_no), AutoNumberKind::Formula => Some(formula_no), _ => None, }; if let Some(v) = next_value { let formatted = format!("{}{}{}", prefix, format_number(shape, v), suffix); for record in paragraph.records.iter_mut() { if let ParagraphRecord::ParaText { runs, .. } = record { for run in runs.iter_mut() { if let ParaTextRun::Control { code, display_text, .. } = run { if code == ControlChar::AUTO_NUMBER && display_text.is_none() { display_text = Some(formatted.clone()); } } } } } // Increment the counter once per paragraph auto-number usage. match kind { AutoNumberKind::Footnote => footnote_no += 1, AutoNumberKind::Endnote => endnote_no += 1, AutoNumberKind::Image => image_no += 1, AutoNumberKind::Table => table_no += 1, AutoNumberKind::Formula => formula_no += 1, _ => {} } } } for record in paragraph.records.iter_mut() { resolve_paragraph_record( record, &mut table_no, &mut footnote_no, &mut endnote_no, &mut image_no, &mut formula_no, ); } } } } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/summary_information.rs	crates/hwp-core/src/document/summary_information.rs	/// SummaryInformation 구조체 / SummaryInformation structure /// /// 스펙 문서 매핑: 3.2.4 - 문서 요약 / Spec mapping: 3.2.4 - Document summary /// /// `\005HwpSummaryInformation` 스트림에는 한글 메뉴의 "파일 - 문서 정보 - 문서 요약"에서 입력한 내용이 저장됩니다. /// The `\005HwpSummaryInformation` stream contains summary information entered from HWP menu "File - Document Info - Document Summary". /// /// Summary Information에 대한 자세한 설명은 MSDN을 참고: /// For detailed description of Summary Information, refer to MSDN: /// - The Summary Information Property Set /// - The DocumentSummaryInformation and UserDefined Property Set /// /// 스펙 문서 표 7: 문서 요약 Property ID 정의 /// Spec document Table 7: Document summary Property ID definitions use crate::error::HwpError; use crate::types::{INT32, UINT32}; use serde::{Deserialize, Serialize}; /// 문서 요약 정보 / Document summary information #[derive(Debug, Clone, Serialize, Deserialize, Default)] pub struct SummaryInformation { /// 제목 / Title (PIDSI_TITLE, 0x00000002) pub title: Option<String>, /// 주제 / Subject (PIDSI_SUBJECT, 0x00000003) pub subject: Option<String>, /// 작성자 / Author (PIDSI_AUTHOR, 0x00000004) pub author: Option<String>, /// 키워드 / Keywords (PIDSI_KEYWORDS, 0x00000005) pub keywords: Option<String>, /// 주석 / Comments (PIDSI_COMMENTS, 0x00000006) pub comments: Option<String>, /// 마지막 저장한 사람 / Last Saved By (PIDSI_LASTAUTHOR, 0x00000008) pub last_saved_by: Option<String>, /// 수정 번호 / Revision Number (PIDSI_REVNUMBER, 0x00000009) pub revision_number: Option<String>, /// 마지막 인쇄 시간 (UTC+9 ISO 8601 형식) / Last Printed (PIDSI_LASTPRINTED, 0x0000000B) (UTC+9 ISO 8601 format) #[serde(skip_serializing_if = "Option::is_none")] pub last_printed: Option<String>, /// 생성 시간/날짜 (UTC+9 ISO 8601 형식) / Create Time/Date (PIDSI_CREATE_DTM, 0x0000000C) (UTC+9 ISO 8601 format) #[serde(skip_serializing_if = "Option::is_none")] pub create_time: Option<String>, /// 마지막 저장 시간/날짜 (UTC+9 ISO 8601 형식) / Last saved Time/Date (PIDSI_LASTSAVE_DTM, 0x0000000D) (UTC+9 ISO 8601 format) #[serde(skip_serializing_if = "Option::is_none")] pub last_saved_time: Option<String>, /// 페이지 수 / Number of Pages (PIDSI_PAGECOUNT, 0x0000000E) pub page_count: Option<INT32>, /// 날짜 문자열 (사용자 정의) / Date String (User define) (HWPPIDSI_DATE_STR, 0x00000014) pub date_string: Option<String>, /// 문단 수 (사용자 정의) / Para Count (User define) (HWPPIDSI_PARACOUNT, 0x00000015) pub para_count: Option<INT32>, } /// FILETIME 구조체 (Windows FILETIME 형식) / FILETIME structure (Windows FILETIME format) /// 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601 (UTC) #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct FileTime { /// Low 32 bits / 하위 32비트 pub low: UINT32, /// High 32 bits / 상위 32비트 pub high: UINT32, } impl FileTime { /// FILETIME을 Unix timestamp (초)로 변환 / Convert FILETIME to Unix timestamp (seconds) pub fn to_unix_timestamp(self) -> i64 { // FILETIME epoch: January 1, 1601 // Unix epoch: January 1, 1970 // Difference: 11644473600 seconds = 0x019DB1DED53E8000 in 100-nanosecond intervals let filetime = ((self.high as u64) << 32) \| (self.low as u64); let unix_time = filetime as i64 - 0x019DB1DED53E8000; unix_time / 10_000_000 // Convert from 100-nanosecond intervals to seconds } /// FILETIME을 UTC+9 시간대의 ISO 8601 문자열로 변환 / Convert FILETIME to ISO 8601 string in UTC+9 timezone pub fn to_utc9_string(self) -> String { use std::time::{Duration, UNIX_EPOCH}; let unix_timestamp = self.to_unix_timestamp(); if unix_timestamp < 0 { return "1970-01-01T00:00:00+09:00".to_string(); } let duration = Duration::from_secs(unix_timestamp as u64); let datetime = UNIX_EPOCH + duration; // UTC+9로 변환 (9시간 추가) // Convert to UTC+9 (add 9 hours) let utc9_datetime = datetime + Duration::from_secs(9 * 3600); // ISO 8601 형식으로 변환 (YYYY-MM-DDTHH:MM:SS+09:00) // Convert to ISO 8601 format (YYYY-MM-DDTHH:MM:SS+09:00) let total_secs = utc9_datetime.duration_since(UNIX_EPOCH).unwrap().as_secs(); let days = total_secs / 86400; let secs_in_day = total_secs % 86400; let hours = secs_in_day / 3600; let minutes = (secs_in_day % 3600) / 60; let seconds = secs_in_day % 60; // 1970-01-01부터의 일수로 날짜 계산 // Calculate date from days since 1970-01-01 let mut year = 1970; let mut day_of_year = days as i32; loop { let days_in_year = if is_leap_year(year) { 366 } else { 365 }; if day_of_year < days_in_year { break; } day_of_year -= days_in_year; year += 1; } let mut month = 1; let mut day = day_of_year + 1; let days_in_month = [ 31, if is_leap_year(year) { 29 } else { 28 }, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, ]; for &dim in &days_in_month { if day <= dim { break; } day -= dim; month += 1; } format!( "{:04}-{:02}-{:02}T{:02}:{:02}:{:02}+09:00", year, month, day, hours, minutes, seconds ) } } fn is_leap_year(year: i32) -> bool { year % 4 == 0 && (year % 100 != 0 \|\| year % 400 == 0) } /// Property ID 상수 / Property ID constants mod property_ids { pub const PID_CODEPAGE: u32 = 0x00000001; // Codepage (VT_I2) pub const PIDSI_TITLE: u32 = 0x00000002; pub const PIDSI_SUBJECT: u32 = 0x00000003; pub const PIDSI_AUTHOR: u32 = 0x00000004; pub const PIDSI_KEYWORDS: u32 = 0x00000005; pub const PIDSI_COMMENTS: u32 = 0x00000006; pub const PIDSI_LASTAUTHOR: u32 = 0x00000008; pub const PIDSI_REVNUMBER: u32 = 0x00000009; pub const PIDSI_LASTPRINTED: u32 = 0x0000000B; pub const PIDSI_CREATE_DTM: u32 = 0x0000000C; pub const PIDSI_LASTSAVE_DTM: u32 = 0x0000000D; pub const PIDSI_PAGECOUNT: u32 = 0x0000000E; pub const HWPPIDSI_DATE_STR: u32 = 0x00000014; pub const HWPPIDSI_PARACOUNT: u32 = 0x00000015; } /// VT (Variant Type) 상수 / VT (Variant Type) constants /// 내부 사용 전용 / Internal use only const VT_LPSTR: u32 = 0x001E; // 30 (0x1E) - ANSI string const VT_LPWSTR: u32 = 0x001F; // 31 (0x1F) - Wide string (UTF-16LE) const VT_FILETIME: u32 = 0x0040; // 64 (0x40) const VT_I2: u32 = 0x0002; // 2 (16-bit signed integer, used for codepage) const VT_I4: u32 = 0x0003; // 3 impl SummaryInformation { /// SummaryInformation을 바이트 배열에서 파싱합니다. / Parse SummaryInformation from byte array. /// /// # Arguments /// * `data` - \005HwpSummaryInformation 스트림의 원시 바이트 데이터 / Raw byte data of \005HwpSummaryInformation stream /// /// # Returns /// 파싱된 SummaryInformation 구조체 / Parsed SummaryInformation structure /// /// # Note /// MSDN Property Set 형식을 파싱합니다. /// Parses MSDN Property Set format. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.is_empty() { return Ok(SummaryInformation::default()); } let mut result = SummaryInformation::default(); // MSDN Property Set 형식 파싱 / Parse MSDN Property Set format // PropertySetStreamHeader 구조: // - ByteOrder (UINT16, 2 bytes) // - Version (UINT16, 2 bytes) // - SystemIdentifier (UINT32, 4 bytes) - pyhwp 참고 // - CLSID (16 bytes) // - propsetDescList (N_ARRAY, 가변 길이) // - 각 PropertySetDesc: FMTID (16 bytes) + Offset (4 bytes) = 20 bytes // - N_ARRAY는 먼저 개수(UINT32, 4 bytes)를 읽고, 그 다음 항목들을 읽음 if data.len() < 24 { return Err(HwpError::insufficient_data("Property Set header", 24, data.len())); } let mut offset = 0; // Byte order (2 bytes): 0xFEFF (little-endian) or 0xFFFE (big-endian) // MSDN Property Set 형식에서는 두 가지 모두 지원 // MSDN Property Set format supports both // Note: Byte order field is stored as raw bytes, not in a specific endianness // 주의: Byte order 필드는 raw 바이트로 저장되며, 특정 엔디언으로 저장되지 않음 // 0xFEFF (stored as [0xFE, 0xFF]) means little-endian // 0xFEFF ([0xFE, 0xFF]로 저장)는 little-endian을 의미 // 0xFFFE (stored as [0xFF, 0xFE]) means big-endian // 0xFFFE ([0xFF, 0xFE]로 저장)는 big-endian을 의미 let byte_order_bytes = [data[offset], data[offset + 1]]; // Read as big-endian to get the actual BOM value // 실제 BOM 값을 얻기 위해 big-endian으로 읽기 let byte_order = u16::from_be_bytes(byte_order_bytes); let is_big_endian = byte_order == 0xFFFE; if byte_order != 0xFEFF && byte_order != 0xFFFE { return Err(HwpError::UnexpectedValue { field: "Property Set byte order".to_string(), expected: "0xFEFF or 0xFFFE".to_string(), found: format!("0x{:04X}", byte_order), }); } offset += 2; // Version (2 bytes): Usually 0x0000 offset += 2; // SystemIdentifier (4 bytes): UINT32 (pyhwp 참고) // 실제 데이터를 보면 [5, 1, 2, 0]이 SystemIdentifier인 것 같습니다 // Looking at actual data, [5, 1, 2, 0] seems to be SystemIdentifier offset += 4; // CLSID (16 bytes): GUID, skip offset += 16; // propsetDescList: N_ARRAY이므로 먼저 개수 읽기 // propsetDescList: N_ARRAY, so read count first // N_ARRAY는 counttype (UINT32)로 개수를 읽습니다 // N_ARRAY reads count using counttype (UINT32) if offset + 4 > data.len() { return Err(HwpError::insufficient_data( "propsetDescList count", 4, data.len() - offset, )); } let num_property_sets = if is_big_endian { UINT32::from_be_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]) } else { UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]) }; offset += 4; if num_property_sets == 0 { return Ok(result); } // 첫 번째 PropertySetDesc 읽기 (일반적으로 하나만 있음) // Read first PropertySetDesc (usually only one) // 각 PropertySetDesc는 FMTID (16 bytes) + Offset (4 bytes) = 20 bytes // Each PropertySetDesc is FMTID (16 bytes) + Offset (4 bytes) = 20 bytes if offset + 20 > data.len() { return Err(HwpError::InsufficientData { field: "PropertySetDesc".to_string(), expected: offset + 20, actual: data.len(), }); } // FMTID (16 bytes) 건너뛰기 / Skip FMTID (16 bytes) offset += 16; // 첫 번째 PropertySetDesc의 offset 읽기 // Read offset of first PropertySetDesc // PropertySetDesc 구조: FMTID (16 bytes) + Offset (4 bytes) // PropertySetDesc structure: FMTID (16 bytes) + Offset (4 bytes) if offset + 4 > data.len() { return Err(HwpError::insufficient_data( "PropertySetDesc offset", 4, data.len() - offset, )); } // PropertySetDesc의 offset은 byte order에 따라 읽어야 함 // PropertySetDesc offset should be read according to byte order // 실제 데이터를 보면 offset 44에서 [48, 0, 0, 0] = 0x00000030 = 48 (little-endian) // Looking at actual data, at offset 44 we have [48, 0, 0, 0] = 0x00000030 = 48 (little-endian) let property_set_offset = if is_big_endian { UINT32::from_be_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]) as usize } else { UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]) as usize }; let property_set_start = property_set_offset; if property_set_start >= data.len() { return Err(HwpError::UnexpectedValue { field: format!("Property Set offset (start={})", property_set_start), expected: format!("< {}", data.len()), found: property_set_start.to_string(), }); } // Property Set Header: Size (4) + NumProperties (4) + Property entries if property_set_start + 8 > data.len() { return Err(HwpError::insufficient_data( "Property Set header", 8, data.len() - property_set_start, )); } // Size (4 bytes): Size of property set (from current offset to end of property set) let _property_set_size = if is_big_endian { UINT32::from_be_bytes([ data[property_set_start], data[property_set_start + 1], data[property_set_start + 2], data[property_set_start + 3], ]) as usize } else { UINT32::from_le_bytes([ data[property_set_start], data[property_set_start + 1], data[property_set_start + 2], data[property_set_start + 3], ]) as usize }; let mut offset = property_set_start + 4; // NumProperties (4 bytes): Number of properties let num_properties = if is_big_endian { UINT32::from_be_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]) } else { UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]) }; offset += 4; // Property entries: Each entry is Property ID (4) + Offset (4) = 8 bytes let property_entries_start = offset; let property_entries_size = (num_properties as usize) * 8; if offset + property_entries_size > data.len() { return Err(HwpError::InsufficientData { field: "property entries".to_string(), expected: offset + property_entries_size, actual: data.len(), }); } // Parse properties: find codepage first, then parse all properties // Property 파싱: 먼저 codepage를 찾고, 그 다음 모든 property 파싱 let mut codepage: u16 = 0xFFFF; // Default: invalid codepage for i in 0..num_properties { let entry_offset = property_entries_start + (i as usize * 8); // Property ID (4 bytes) let property_id = if is_big_endian { UINT32::from_be_bytes([ data[entry_offset], data[entry_offset + 1], data[entry_offset + 2], data[entry_offset + 3], ]) } else { UINT32::from_le_bytes([ data[entry_offset], data[entry_offset + 1], data[entry_offset + 2], data[entry_offset + 3], ]) }; // Offset (4 bytes): Offset from Property Set start (Size field) let value_offset = if is_big_endian { UINT32::from_be_bytes([ data[entry_offset + 4], data[entry_offset + 5], data[entry_offset + 6], data[entry_offset + 7], ]) as usize } else { UINT32::from_le_bytes([ data[entry_offset + 4], data[entry_offset + 5], data[entry_offset + 6], data[entry_offset + 7], ]) as usize }; let value_data_offset = property_set_start + value_offset; if value_data_offset >= data.len() { continue; } // Find codepage first if property_id == property_ids::PID_CODEPAGE { if let Ok(cp) = Self::parse_vt_i2(&data[value_data_offset..], is_big_endian) { codepage = cp as u16; } continue; } // Parse property value match property_id { property_ids::PIDSI_TITLE => { result.title = Self::parse_vt_lpstr(&data[value_data_offset..], is_big_endian, codepage) .ok(); } property_ids::PIDSI_SUBJECT => { result.subject = Self::parse_vt_lpstr(&data[value_data_offset..], is_big_endian, codepage) .ok(); } property_ids::PIDSI_AUTHOR => { result.author = Self::parse_vt_lpstr(&data[value_data_offset..], is_big_endian, codepage) .ok(); } property_ids::PIDSI_KEYWORDS => { result.keywords = Self::parse_vt_lpstr(&data[value_data_offset..], is_big_endian, codepage) .ok(); } property_ids::PIDSI_COMMENTS => { result.comments = Self::parse_vt_lpstr(&data[value_data_offset..], is_big_endian, codepage) .ok(); } property_ids::PIDSI_LASTAUTHOR => { result.last_saved_by = Self::parse_vt_lpstr(&data[value_data_offset..], is_big_endian, codepage) .ok(); } property_ids::PIDSI_REVNUMBER => { result.revision_number = Self::parse_vt_lpstr(&data[value_data_offset..], is_big_endian, codepage) .ok(); } property_ids::PIDSI_LASTPRINTED => { result.last_printed = Self::parse_vt_filetime(&data[value_data_offset..], is_big_endian) .ok() .map(\|ft\| ft.to_utc9_string()); } property_ids::PIDSI_CREATE_DTM => { result.create_time = Self::parse_vt_filetime(&data[value_data_offset..], is_big_endian) .ok() .map(\|ft\| ft.to_utc9_string()); } property_ids::PIDSI_LASTSAVE_DTM => { result.last_saved_time = Self::parse_vt_filetime(&data[value_data_offset..], is_big_endian) .ok() .map(\|ft\| ft.to_utc9_string()); } property_ids::PIDSI_PAGECOUNT => { result.page_count = Self::parse_vt_i4(&data[value_data_offset..], is_big_endian).ok(); } property_ids::HWPPIDSI_DATE_STR => { result.date_string = Self::parse_vt_lpstr(&data[value_data_offset..], is_big_endian, codepage) .ok(); } property_ids::HWPPIDSI_PARACOUNT => { result.para_count = Self::parse_vt_i4(&data[value_data_offset..], is_big_endian).ok(); } _ => { // Unknown property ID, skip } } } Ok(result) } /// VT_I2 파싱 (16-bit signed integer, codepage에 사용) / Parse VT_I2 (16-bit signed integer, used for codepage) /// Format: VT type (4 bytes) + Value (2 bytes) fn parse_vt_i2(data: &[u8], is_big_endian: bool) -> Result<i16, HwpError> { if data.len() < 6 { return Err(HwpError::insufficient_data("VT_I2", 6, data.len())); } // VT type (4 bytes): Should be VT_I2 (0x0002) let vt_type = if is_big_endian { UINT32::from_be_bytes([data[0], data[1], data[2], data[3]]) } else { UINT32::from_le_bytes([data[0], data[1], data[2], data[3]]) }; if vt_type != VT_I2 { return Err(HwpError::UnexpectedValue { field: "VT_I2 type".to_string(), expected: format!("0x{:08X}", VT_I2), found: format!("0x{:08X}", vt_type), }); } // Value (2 bytes): Signed 16-bit integer let value = if is_big_endian { i16::from_be_bytes([data[4], data[5]]) } else { i16::from_le_bytes([data[4], data[5]]) }; Ok(value) } /// VT_LPSTR 또는 VT_LPWSTR 파싱 (문자열) / Parse VT_LPSTR or VT_LPWSTR (string) /// Format: VT type (4 bytes) + Length (4 bytes) + String (null-terminated) /// codepage에 따라 적절한 인코딩으로 디코딩 / Decode using appropriate encoding based on codepage fn parse_vt_lpstr(data: &[u8], is_big_endian: bool, codepage: u16) -> Result<String, HwpError> { if data.len() < 8 { return Err(HwpError::insufficient_data("VT_LPSTR/VT_LPWSTR", 8, data.len())); } // VT type (4 bytes): Should be VT_LPSTR (0x001E) or VT_LPWSTR (0x001F) let vt_type = if is_big_endian { UINT32::from_be_bytes([data[0], data[1], data[2], data[3]]) } else { UINT32::from_le_bytes([data[0], data[1], data[2], data[3]]) }; // VT_LPWSTR (wide string) 처리 if vt_type == VT_LPWSTR { return Self::parse_vt_lpwstr(data, is_big_endian); } if vt_type != VT_LPSTR { return Err(HwpError::UnexpectedValue { field: "VT_LPSTR/VT_LPWSTR type".to_string(), expected: format!("0x{:08X} or 0x{:08X}", VT_LPSTR, VT_LPWSTR), found: format!("0x{:08X}", vt_type), }); } // Length (4 bytes): String length in bytes (including null terminator) // hwplib의 CodePageString처럼 size만큼 읽음 let size = if is_big_endian { UINT32::from_be_bytes([data[4], data[5], data[6], data[7]]) as usize } else { UINT32::from_le_bytes([data[4], data[5], data[6], data[7]]) as usize }; if data.len() < 8 + size { return Err(HwpError::InsufficientData { field: "VT_LPSTR string".to_string(), expected: 8 + size, actual: data.len(), }); } // String data: size만큼 읽음 (hwplib의 CodePageString처럼) let string_data = &data[8..8 + size]; // Decode string based on codepage // codepage에 따라 적절한 인코딩으로 디코딩 Self::decode_string_by_codepage(string_data, codepage) .map_err(\|e\| HwpError::EncodingError { reason: format!( "Failed to decode VT_LPSTR string with codepage {}: {}", codepage, e ), }) } /// VT_FILETIME 파싱 (날짜/시간) / Parse VT_FILETIME (date/time) /// Format: VT type (4 bytes) + FILETIME (8 bytes: low 4 bytes + high 4 bytes) fn parse_vt_filetime(data: &[u8], is_big_endian: bool) -> Result<FileTime, HwpError> { if data.len() < 12 { return Err(HwpError::insufficient_data("VT_FILETIME", 12, data.len())); } // VT type (4 bytes): Should be VT_FILETIME (0x0040) let vt_type = if is_big_endian { UINT32::from_be_bytes([data[0], data[1], data[2], data[3]]) } else { UINT32::from_le_bytes([data[0], data[1], data[2], data[3]]) }; if vt_type != VT_FILETIME { return Err(HwpError::UnexpectedValue { field: "VT_FILETIME type".to_string(), expected: format!("0x{:08X}", VT_FILETIME), found: format!("0x{:08X}", vt_type), }); } // FILETIME: Low 32 bits (4 bytes) + High 32 bits (4 bytes) let low = if is_big_endian { UINT32::from_be_bytes([data[4], data[5], data[6], data[7]]) } else { UINT32::from_le_bytes([data[4], data[5], data[6], data[7]]) }; let high = if is_big_endian { UINT32::from_be_bytes([data[8], data[9], data[10], data[11]]) } else { UINT32::from_le_bytes([data[8], data[9], data[10], data[11]]) }; Ok(FileTime { low, high }) } /// VT_LPWSTR 파싱 (Wide string, UTF-16LE) / Parse VT_LPWSTR (Wide string, UTF-16LE) /// Format: VT type (4 bytes) + Length (4 bytes, character count) + String (UTF-16LE, null-terminated) /// hwplib의 UnicodeString 구현 참고 fn parse_vt_lpwstr(data: &[u8], is_big_endian: bool) -> Result<String, HwpError> { if data.len() < 8 { return Err(HwpError::insufficient_data("VT_LPWSTR", 8, data.len())); } // VT type (4 bytes): Should be VT_LPWSTR (0x001F) let vt_type = if is_big_endian { UINT32::from_be_bytes([data[0], data[1], data[2], data[3]]) } else { UINT32::from_le_bytes([data[0], data[1], data[2], data[3]]) }; if vt_type != VT_LPWSTR { return Err(HwpError::UnexpectedValue { field: "VT_LPWSTR type".to_string(), expected: format!("0x{:08X}", VT_LPWSTR), found: format!("0x{:08X}", vt_type), }); } // Length (4 bytes): Character count (not byte count) // hwplib의 UnicodeString처럼 character count를 읽음 let char_count = if is_big_endian { UINT32::from_be_bytes([data[4], data[5], data[6], data[7]]) as usize } else { UINT32::from_le_bytes([data[4], data[5], data[6], data[7]]) as usize }; if char_count == 0 { return Ok(String::new()); } // UTF-16LE: 각 character는 2 bytes let byte_count = char_count * 2; if data.len() < 8 + byte_count { return Err(HwpError::InsufficientData { field: "VT_LPWSTR string".to_string(), expected: 8 + byte_count, actual: data.len(), }); } // String data: UTF-16LE bytes // hwplib의 UnicodeString처럼 length * 2 바이트를 읽음 let string_bytes = &data[8..8 + byte_count]; // UTF-16LE 디코딩 (hwplib의 StringUtil.getFromUnicodeLE처럼) let mut chars = Vec::new(); for i in (0..string_bytes.len()).step_by(2) { if i + 1 < string_bytes.len() { let code_point = u16::from_le_bytes([string_bytes[i], string_bytes[i + 1]]); if code_point == 0 { break; // null terminator } if let Some(ch) = char::from_u32(code_point as u32) { chars.push(ch); } } } Ok(chars.into_iter().collect()) } /// Codepage에 따라 문자열 디코딩 / Decode string based on codepage /// hwplib의 CodePageString.getJavaValue() 로직 참고 fn decode_string_by_codepage(data: &[u8], codepage: u16) -> Result<String, HwpError> { use encoding_rs::*; if data.is_empty() { return Ok(String::new()); } // Codepage 상수 (hwplib 참고) const CP_UTF16: u16 = 1200; const CP_UTF16_BE: u16 = 1201; const CP_UTF8: u16 = 65001; const CP_MS949: u16 = 949; const CP_WINDOWS_1252: u16 = 1252; // hwplib처럼 codepage가 -1 (0xFFFF)이면 기본 인코딩 사용 let result = if codepage == 0xFFFF { // Default: try UTF-8, fallback to Windows-1252 String::from_utf8(data.to_vec()) .unwrap_or_else(\|_\| WINDOWS_1252.decode(data).0.to_string()) } else { match codepage { CP_UTF16 => { let mut chars = Vec::new(); for i in (0..data.len()).step_by(2) { if i + 1 < data.len() { let code_point = u16::from_le_bytes([data[i], data[i + 1]]); if let Some(ch) = char::from_u32(code_point as u32) { if ch != '\0' { chars.push(ch); } } } } chars.into_iter().collect() } CP_UTF16_BE => { let mut chars = Vec::new(); for i in (0..data.len()).step_by(2) { if i + 1 < data.len() { let code_point = u16::from_be_bytes([data[i], data[i + 1]]); if let Some(ch) = char::from_u32(code_point as u32) { if ch != '\0' { chars.push(ch); } } } } chars.into_iter().collect() } CP_UTF8 => String::from_utf8(data.to_vec()) .map_err(\|e\| HwpError::EncodingError { reason: format!("UTF-8 decode error: {}", e), })?, CP_MS949 => EUC_KR.decode(data).0.to_string(), CP_WINDOWS_1252 => WINDOWS_1252.decode(data).0.to_string(), _ => { // Unknown codepage: try UTF-8, fallback to Windows-1252 String::from_utf8(data.to_vec()) .unwrap_or_else(\|_\| WINDOWS_1252.decode(data).0.to_string()) } } }; // Remove null terminator (hwplib의 CodePageString.getJavaValue처럼) // hwplib는 null terminator를 찾아서 substring(0, terminator)를 반환 let terminator = result.find('\0'); if let Some(pos) = terminator { Ok(result[..pos].to_string()) } else { Ok(result) } } /// VT_I4 파싱 (32-bit signed integer) / Parse VT_I4 (32-bit signed integer) /// Format: VT type (4 bytes) + Value (4 bytes) fn parse_vt_i4(data: &[u8], is_big_endian: bool) -> Result<INT32, HwpError> { if data.len() < 8 { return Err(HwpError::insufficient_data("VT_I4", 8, data.len())); } // VT type (4 bytes): Should be VT_I4 (0x0003) let vt_type = if is_big_endian { UINT32::from_be_bytes([data[0], data[1], data[2], data[3]]) } else { UINT32::from_le_bytes([data[0], data[1], data[2], data[3]]) }; if vt_type != VT_I4 { return Err(HwpError::UnexpectedValue { field: "VT_I4 type".to_string(), expected: format!("0x{:08X}", VT_I4), found: format!("0x{:08X}", vt_type), }); } // Value (4 bytes): Signed 32-bit integer let value = if is_big_endian {	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	true
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/constants.rs	crates/hwp-core/src/document/constants.rs	/// 공통 태그 상수 정의 / Common tag constants definition /// /// HWPTAG_BEGIN = 0x10 (한글 내부 사용을 위해 예약된 영역의 시작) / HWPTAG_BEGIN = 0x10 (start of reserved area for HWP internal use) /// 데이터 레코드 시작 값 / Data record start value pub const HWPTAG_BEGIN: u16 = 0x10;	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/scripts/script_version.rs	crates/hwp-core/src/document/scripts/script_version.rs	/// ScriptVersion 구조체 / ScriptVersion structure /// /// 스펙 문서 매핑: 표 8 - 스크립트 버전 / Spec mapping: Table 8 - Script version use crate::error::HwpError; use crate::types::DWORD; use serde::{Deserialize, Serialize}; /// 스크립트 버전 / Script version #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ScriptVersion { /// 스크립트 버전 HIGH / Script version HIGH pub high: DWORD, /// 스크립트 버전 LOW / Script version LOW pub low: DWORD, } impl ScriptVersion { /// ScriptVersion을 바이트 배열에서 파싱합니다. / Parse ScriptVersion from byte array. /// /// # Arguments /// * `data` - JScriptVersion 스트림의 원시 바이트 데이터 / Raw byte data of JScriptVersion stream /// /// # Returns /// 파싱된 ScriptVersion 구조체 / Parsed ScriptVersion structure /// /// # Note /// 스펙 문서 표 8에 따르면 스크립트 버전은 8바이트입니다: /// - DWORD (4 bytes): 스크립트 버전 HIGH /// - DWORD (4 bytes): 스크립트 버전 LOW /// According to spec Table 8, script version is 8 bytes: /// - DWORD (4 bytes): Script version HIGH /// - DWORD (4 bytes): Script version LOW pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 8 { return Err(HwpError::insufficient_data("ScriptVersion", 8, data.len())); } // DWORD 스크립트 버전 HIGH (4 bytes) / Script version HIGH (4 bytes) let high = DWORD::from_le_bytes([data[0], data[1], data[2], data[3]]); // DWORD 스크립트 버전 LOW (4 bytes) / Script version LOW (4 bytes) let low = DWORD::from_le_bytes([data[4], data[5], data[6], data[7]]); Ok(ScriptVersion { high, low }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/scripts/mod.rs	crates/hwp-core/src/document/scripts/mod.rs	/// Scripts parsing module /// /// This module handles parsing of HWP Scripts storage. /// /// 스펙 문서 매핑: 3.2.9 - 스크립트 / Spec mapping: 3.2.9 - Scripts mod script; mod script_version; pub use script::Script; pub use script_version::ScriptVersion; use crate::cfb::CfbParser; use crate::error::HwpError; use serde::{Deserialize, Serialize}; /// Scripts structure /// 스크립트 구조 #[derive(Debug, Clone, Default, Serialize, Deserialize)] pub struct Scripts { /// Script version (from JScriptVersion stream) / 스크립트 버전 (JScriptVersion 스트림) pub version: Option<ScriptVersion>, /// Default script (from DefaultJScript stream) / 기본 스크립트 (DefaultJScript 스트림) pub default_script: Option<Script>, } impl Scripts { /// Parse Scripts storage from CFB structure /// CFB 구조에서 Scripts 스토리지를 파싱합니다. /// /// # Arguments /// * `cfb` - CompoundFile structure (mutable reference required) / CompoundFile 구조체 (가변 참조 필요) /// /// # Returns /// Parsed Scripts structure / 파싱된 Scripts 구조체 /// /// # Note /// 스펙 문서 3.2.9에 따르면 Scripts 스토리지에는 다음 스트림이 포함됩니다: /// - JScriptVersion: 스크립트 버전 (표 8) /// - DefaultJScript: 스크립트 내용 (표 9) /// According to spec 3.2.9, Scripts storage contains the following streams: /// - JScriptVersion: Script version (Table 8) /// - DefaultJScript: Script content (Table 9) pub fn parse(cfb: &mut cfb::CompoundFile<std::io::Cursor<&[u8]>>) -> Result<Self, HwpError> { let mut scripts = Scripts::default(); // Parse JScriptVersion stream // JScriptVersion 스트림 파싱 / Parse JScriptVersion stream // 스펙 문서 표 8: 스크립트 버전은 8바이트 (DWORD HIGH + DWORD LOW) // Spec Table 8: Script version is 8 bytes (DWORD HIGH + DWORD LOW) if let Ok(version_data) = CfbParser::read_nested_stream(cfb, "Scripts", "JScriptVersion") { match ScriptVersion::parse(&version_data) { Ok(version) => { scripts.version = Some(version); } Err(e) => { #[cfg(debug_assertions)] eprintln!("Warning: Failed to parse JScriptVersion stream: {}", e); } } } // Parse DefaultJScript stream // DefaultJScript 스트림 파싱 / Parse DefaultJScript stream // 스펙 문서 표 9: 스크립트 내용은 가변 길이 // Spec Table 9: Script content is variable length if let Ok(script_data) = CfbParser::read_nested_stream(cfb, "Scripts", "DefaultJScript") { match Script::parse(&script_data) { Ok(default_script) => { scripts.default_script = Some(default_script); } Err(e) => { #[cfg(debug_assertions)] eprintln!("Warning: Failed to parse DefaultJScript stream: {}", e); } } } Ok(scripts) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/scripts/script.rs	crates/hwp-core/src/document/scripts/script.rs	/// Script 구조체 / Script structure /// /// 스펙 문서 매핑: 표 9 - 스크립트 / Spec mapping: Table 9 - Script use crate::error::HwpError; use crate::types::{decode_utf16le, DWORD}; use serde::{Deserialize, Serialize}; /// 스크립트 / Script #[derive(Debug, Clone, Serialize, Deserialize)] pub struct Script { /// 스크립트 헤더 / Script header pub header: String, /// 스크립트 소스 / Script source pub source: String, /// 스크립트 Pre 소스 / Script pre source pub pre_source: String, /// 스크립트 Post 소스 / Script post source pub post_source: String, } impl Script { /// Script를 바이트 배열에서 파싱합니다. / Parse Script from byte array. /// /// # Arguments /// * `data` - DefaultJScript 스트림의 원시 바이트 데이터 / Raw byte data of DefaultJScript stream /// /// # Returns /// 파싱된 Script 구조체 / Parsed Script structure /// /// # Note /// 스펙 문서 표 9에 따르면 스크립트는 다음 구조를 가집니다: /// - DWORD (4 bytes): 스크립트 헤더 길이 (len1) /// - WCHAR array[len1] (2×len1 bytes): 스크립트 헤더 /// - DWORD (4 bytes): 스크립트 소스 길이 (len2) /// - WCHAR array[len2] (2×len2 bytes): 스크립트 소스 /// - DWORD (4 bytes): 스크립트 Pre 소스 길이 (len3) /// - WCHAR array[len3] (2×len3 bytes): 스크립트 Pre 소스 /// - DWORD (4 bytes): 스크립트 Post 소스 길이 (len4) /// - WCHAR array[len4] (2×len4 bytes): 스크립트 Post 소스 /// - DWORD (4 bytes): 스크립트 end flag (-1) /// According to spec Table 9, script has the following structure: /// - DWORD (4 bytes): Script header length (len1) /// - WCHAR array[len1] (2×len1 bytes): Script header /// - DWORD (4 bytes): Script source length (len2) /// - WCHAR array[len2] (2×len2 bytes): Script source /// - DWORD (4 bytes): Script pre source length (len3) /// - WCHAR array[len3] (2×len3 bytes): Script pre source /// - DWORD (4 bytes): Script post source length (len4) /// - WCHAR array[len4] (2×len4 bytes): Script post source /// - DWORD (4 bytes): Script end flag (-1) pub fn parse(data: &[u8]) -> Result<Self, HwpError> { let mut offset = 0; // 최소 20바이트 필요 (4개의 DWORD 길이 필드 + end flag) / Need at least 20 bytes (4 DWORD length fields + end flag) if data.len() < 20 { return Err(HwpError::insufficient_data("Script", 20, data.len())); } // DWORD 스크립트 헤더 길이 (4 bytes) / Script header length (4 bytes) let header_len = DWORD::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]) as usize; offset += 4; // WCHAR array[len1] 스크립트 헤더 (2×len1 bytes) / Script header (2×len1 bytes) let header = if header_len > 0 { let header_bytes_len = header_len.saturating_mul(2); if offset + header_bytes_len <= data.len() { let header_bytes = &data[offset..offset + header_bytes_len]; decode_utf16le(header_bytes).unwrap_or_default() } else { String::new() } } else { String::new() }; offset = offset.saturating_add(header_len.saturating_mul(2)); // DWORD 스크립트 소스 길이 (4 bytes) / Script source length (4 bytes) if offset + 4 > data.len() { return Err(HwpError::insufficient_data( "Script source length", 4, data.len().saturating_sub(offset), )); } let source_len = DWORD::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]) as usize; offset += 4; // WCHAR array[len2] 스크립트 소스 (2×len2 bytes) / Script source (2×len2 bytes) let source = if source_len > 0 { let source_bytes_len = source_len.saturating_mul(2); if offset + source_bytes_len <= data.len() { let source_bytes = &data[offset..offset + source_bytes_len]; decode_utf16le(source_bytes).unwrap_or_default() } else { String::new() } } else { String::new() }; offset = offset.saturating_add(source_len.saturating_mul(2)); // DWORD 스크립트 Pre 소스 길이 (4 bytes) / Script pre source length (4 bytes) if offset + 4 > data.len() { return Err(HwpError::insufficient_data( "Script pre source length", 4, data.len().saturating_sub(offset), )); } let pre_source_len = DWORD::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]) as usize; offset += 4; // WCHAR array[len3] 스크립트 Pre 소스 (2×len3 bytes) / Script pre source (2×len3 bytes) let pre_source = if pre_source_len > 0 { let pre_source_bytes_len = pre_source_len.saturating_mul(2); if offset + pre_source_bytes_len <= data.len() { let pre_source_bytes = &data[offset..offset + pre_source_bytes_len]; decode_utf16le(pre_source_bytes).unwrap_or_default() } else { String::new() } } else { String::new() }; offset = offset.saturating_add(pre_source_len.saturating_mul(2)); // DWORD 스크립트 Post 소스 길이 (4 bytes) / Script post source length (4 bytes) if offset + 4 > data.len() { return Err(HwpError::insufficient_data( "Script post source length", 4, data.len().saturating_sub(offset), )); } let post_source_len = DWORD::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]) as usize; offset += 4; // WCHAR array[len4] 스크립트 Post 소스 (2×len4 bytes) / Script post source (2×len4 bytes) let post_source = if post_source_len > 0 { let post_source_bytes_len = post_source_len.saturating_mul(2); if offset + post_source_bytes_len <= data.len() { let post_source_bytes = &data[offset..offset + post_source_bytes_len]; decode_utf16le(post_source_bytes).unwrap_or_default() } else { String::new() } } else { String::new() }; offset = offset.saturating_add(post_source_len.saturating_mul(2)); // DWORD 스크립트 end flag (-1) (4 bytes) / Script end flag (-1) (4 bytes) // 검증 목적으로 읽지만 사용하지 않음 / Read for validation but not used if offset + 4 <= data.len() { let end_flag = DWORD::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); if end_flag != 0xFFFFFFFF { #[cfg(debug_assertions)] eprintln!( "Warning: Script end flag is not -1 (0xFFFFFFFF), got 0x{:08X}", end_flag ); } } Ok(Script { header, source, pre_source, post_source, }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/track_change.rs	crates/hwp-core/src/document/docinfo/track_change.rs	/// TrackChange 구조체 / TrackChange structure /// /// 스펙 문서 매핑: 표 4 - 변경 추적 정보 / Spec mapping: Table 4 - Track change information /// 상세 구조는 스펙 문서에 명시되지 않음 / Detailed structure not specified in spec use crate::error::HwpError; use serde::{Deserialize, Serialize}; /// 변경 추적 정보 / Track change information #[derive(Debug, Clone, Serialize, Deserialize)] pub struct TrackChange { /// Raw data (1032바이트) / Raw data (1032 bytes) #[serde(skip)] pub raw_data: Vec<u8>, } impl TrackChange { /// TrackChange를 바이트 배열에서 파싱합니다. / Parse TrackChange from byte array. /// /// # Arguments /// * `data` - TrackChange 데이터 (1032바이트) / TrackChange data (1032 bytes) /// /// # Returns /// 파싱된 TrackChange 구조체 / Parsed TrackChange structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 1032 { return Err(HwpError::insufficient_data("TrackChange", 1032, data.len())); } Ok(TrackChange { raw_data: data[0..1032.min(data.len())].to_vec(), }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/track_change_author.rs	crates/hwp-core/src/document/docinfo/track_change_author.rs	/// TrackChangeAuthor 구조체 / TrackChangeAuthor structure /// /// 스펙 문서 매핑: 표 4 - 변경 추적 작성자 / Spec mapping: Table 4 - Track change author /// 상세 구조는 스펙 문서에 명시되지 않음 / Detailed structure not specified in spec use crate::error::HwpError; use serde::{Deserialize, Serialize}; /// 변경 추적 작성자 / Track change author #[derive(Debug, Clone, Serialize, Deserialize)] pub struct TrackChangeAuthor { /// Raw data (가변) / Raw data (variable) #[serde(skip)] pub raw_data: Vec<u8>, } impl TrackChangeAuthor { /// TrackChangeAuthor를 바이트 배열에서 파싱합니다. / Parse TrackChangeAuthor from byte array. /// /// # Arguments /// * `data` - TrackChangeAuthor 데이터 (가변) / TrackChangeAuthor data (variable) /// /// # Returns /// 파싱된 TrackChangeAuthor 구조체 / Parsed TrackChangeAuthor structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { Ok(TrackChangeAuthor { raw_data: data.to_vec(), }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/id_mappings.rs	crates/hwp-core/src/document/docinfo/id_mappings.rs	/// ID Mappings 구조체 / ID Mappings structure /// /// 스펙 문서 매핑: 표 15 - 아이디 매핑 헤더 / Spec mapping: Table 15 - ID mappings header /// Tag ID: HWPTAG_ID_MAPPINGS /// 전체 길이: 72 바이트 (18개 INT32) / Total length: 72 bytes (18 INT32 values) use crate::error::HwpError; use crate::types::INT32; use serde::{Deserialize, Serialize}; /// ID Mappings 구조체 / ID Mappings structure /// /// 스펙 문서 표 15에 따르면, 각 필드는 해당 타입의 레코드 개수를 나타냅니다. /// According to spec document Table 15, each field represents the count of records of the corresponding type. /// /// 스펙 문서 매핑: 표 15 - 아이디 매핑 헤더, 표 16 - 아이디 매핑 개수 인덱스 /// Spec mapping: Table 15 - ID mappings header, Table 16 - ID mapping count indices #[derive(Debug, Clone, Serialize, Deserialize)] pub struct IdMappings { /// 바이너리 데이터 개수 (HWPTAG_BIN_DATA 레코드 개수, 표 16 인덱스 0) / Binary data count (HWPTAG_BIN_DATA record count, Table 16 index 0) pub binary_data: INT32, /// 한글 글꼴 개수 (HWPTAG_FACE_NAME 레코드 개수, 표 16 인덱스 1) / Korean font count (HWPTAG_FACE_NAME record count, Table 16 index 1) pub font_korean: INT32, /// 영어 글꼴 개수 (HWPTAG_FACE_NAME 레코드 개수, 표 16 인덱스 2) / English font count (HWPTAG_FACE_NAME record count, Table 16 index 2) pub font_english: INT32, /// 한자 글꼴 개수 (HWPTAG_FACE_NAME 레코드 개수, 표 16 인덱스 3) / Chinese font count (HWPTAG_FACE_NAME record count, Table 16 index 3) pub font_chinese: INT32, /// 일어 글꼴 개수 (HWPTAG_FACE_NAME 레코드 개수, 표 16 인덱스 4) / Japanese font count (HWPTAG_FACE_NAME record count, Table 16 index 4) pub font_japanese: INT32, /// 기타 글꼴 개수 (HWPTAG_FACE_NAME 레코드 개수, 표 16 인덱스 5) / Other font count (HWPTAG_FACE_NAME record count, Table 16 index 5) pub font_other: INT32, /// 기호 글꼴 개수 (HWPTAG_FACE_NAME 레코드 개수, 표 16 인덱스 6) / Symbol font count (HWPTAG_FACE_NAME record count, Table 16 index 6) pub font_symbol: INT32, /// 사용자 글꼴 개수 (HWPTAG_FACE_NAME 레코드 개수, 표 16 인덱스 7) / User font count (HWPTAG_FACE_NAME record count, Table 16 index 7) pub font_user: INT32, /// 테두리/배경 개수 (HWPTAG_BORDER_FILL 레코드 배열 크기, 표 16 인덱스 8) / Border/fill count (HWPTAG_BORDER_FILL record array size, Table 16 index 8) pub border_fill: INT32, /// 글자 모양 개수 (HWPTAG_CHAR_SHAPE 레코드 배열 크기, 표 16 인덱스 9) / Character shape count (HWPTAG_CHAR_SHAPE record array size, Table 16 index 9) pub char_shape: INT32, /// 탭 정의 개수 (HWPTAG_TAB_DEF 레코드 배열 크기, 표 16 인덱스 10) / Tab definition count (HWPTAG_TAB_DEF record array size, Table 16 index 10) pub tab_def: INT32, /// 문단 번호 개수 (HWPTAG_NUMBERING 레코드 배열 크기, 표 16 인덱스 11) / Paragraph numbering count (HWPTAG_NUMBERING record array size, Table 16 index 11) pub paragraph_numbering: INT32, /// 글머리표 개수 (HWPTAG_BULLET 레코드 배열 크기, 표 16 인덱스 12) / Bullet count (HWPTAG_BULLET record array size, Table 16 index 12) pub bullet: INT32, /// 문단 모양 개수 (HWPTAG_PARA_SHAPE 레코드 배열 크기, 표 16 인덱스 13) / Paragraph shape count (HWPTAG_PARA_SHAPE record array size, Table 16 index 13) pub paragraph_shape: INT32, /// 스타일 개수 (HWPTAG_STYLE 레코드 배열 크기, 표 16 인덱스 14) / Style count (HWPTAG_STYLE record array size, Table 16 index 14) pub style: INT32, /// 메모 모양 개수 (5.0.2.1 이상, 표 16 인덱스 15) / Memo shape count (5.0.2.1 and above, Table 16 index 15) pub memo_shape: Option<INT32>, /// 변경추적 개수 (5.0.3.2 이상, 표 16 인덱스 16) / Track change count (5.0.3.2 and above, Table 16 index 16) pub track_change: Option<INT32>, /// 변경추적 사용자 개수 (5.0.3.2 이상, 표 16 인덱스 17) / Track change author count (5.0.3.2 and above, Table 16 index 17) pub track_change_author: Option<INT32>, } impl IdMappings { /// IdMappings를 바이트 배열에서 파싱합니다. / Parse IdMappings from byte array. /// /// # Arguments /// * `data` - 최소 72바이트의 데이터 (18개 INT32) / At least 72 bytes of data (18 INT32 values) /// * `version` - FileHeader의 version (버전에 따라 필드 개수가 다를 수 있음) / FileHeader version (field count may vary by version) /// /// # Returns /// 파싱된 IdMappings 구조체 / Parsed IdMappings structure pub fn parse(data: &[u8], _version: u32) -> Result<Self, HwpError> { // 최소 60바이트 (15개 INT32) 필요 / Need at least 60 bytes (15 INT32 values) if data.len() < 60 { return Err(HwpError::insufficient_data("IdMappings", 60, data.len())); } let mut offset = 0; // INT32 배열 읽기 (각 4바이트) / Read INT32 array (4 bytes each) let read_int32 = \|offset: &mut usize\| -> INT32 { let value = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); *offset += 4; value }; // 기본 15개 필드 (60바이트) / Basic 15 fields (60 bytes) let binary_data = read_int32(&mut offset); let font_korean = read_int32(&mut offset); let font_english = read_int32(&mut offset); let font_chinese = read_int32(&mut offset); let font_japanese = read_int32(&mut offset); let font_other = read_int32(&mut offset); let font_symbol = read_int32(&mut offset); let font_user = read_int32(&mut offset); let border_fill = read_int32(&mut offset); let char_shape = read_int32(&mut offset); let tab_def = read_int32(&mut offset); let paragraph_numbering = read_int32(&mut offset); let bullet = read_int32(&mut offset); let paragraph_shape = read_int32(&mut offset); let style = read_int32(&mut offset); // 버전에 따른 선택적 필드 / Optional fields based on version // 레거시 코드 기준: version >= 5017일 때 메모 모양 추가 / Legacy code: memo shape added when version >= 5017 // 스펙 문서: 5.0.2.1 이상 / Spec document: 5.0.2.1 and above // 데이터 크기로 판단: 64바이트 이상이면 메모 모양 필드 존재 / Determine by data size: memo shape field exists if 64 bytes or more let memo_shape = if data.len() >= 64 && offset + 4 <= data.len() { Some(read_int32(&mut offset)) } else { None }; // 변경추적: 레거시 코드 기준 version >= 5032 / Track change: legacy code version >= 5032 // 스펙 문서: 5.0.3.2 이상 / Spec document: 5.0.3.2 and above // 데이터 크기로 판단: 68바이트 이상이면 변경추적 필드 존재 / Determine by data size: track change field exists if 68 bytes or more let track_change = if data.len() >= 68 && offset + 4 <= data.len() { Some(read_int32(&mut offset)) } else { None }; // 변경추적 사용자: 레거시 코드 기준 version >= 5032 / Track change author: legacy code version >= 5032 // 데이터 크기로 판단: 72바이트 이상이면 변경추적 사용자 필드 존재 / Determine by data size: track change author field exists if 72 bytes or more let track_change_author = if data.len() >= 72 && offset + 4 <= data.len() { Some(read_int32(&mut offset)) } else { None }; Ok(IdMappings { binary_data, font_korean, font_english, font_chinese, font_japanese, font_other, font_symbol, font_user, border_fill, char_shape, tab_def, paragraph_numbering, bullet, paragraph_shape, style, memo_shape, track_change, track_change_author, }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/document_properties.rs	crates/hwp-core/src/document/docinfo/document_properties.rs	/// Document Properties 구조체 / Document Properties structure /// /// 스펙 문서 매핑: 표 14 - 문서 속성 / Spec mapping: Table 14 - Document properties /// Tag ID: HWPTAG_DOCUMENT_PROPERTIES /// 전체 길이: 26 바이트 / Total length: 26 bytes use crate::error::HwpError; use crate::types::{UINT16, UINT32}; use serde::{Deserialize, Serialize}; /// 문서 속성 구조체 / Document properties structure #[derive(Debug, Clone, Serialize, Deserialize)] pub struct DocumentProperties { /// 구역 개수 / Area count pub area_count: UINT16, /// 문서 내 각종 시작번호에 대한 정보 / Start number information pub start_number_info: UINT16, /// 페이지 시작 번호 / Page start number pub page_start_number: UINT16, /// 각주 시작 번호 / Footnote start number pub footnote_start_number: UINT16, /// 미주 시작 번호 / Endnote start number pub endnote_start_number: UINT16, /// 그림 시작 번호 / Image start number pub image_start_number: UINT16, /// 표 시작 번호 / Table start number pub table_start_number: UINT16, /// 수식 시작 번호 / Formula start number pub formula_start_number: UINT16, /// 문서 내 캐럿의 위치 정보 (리스트 아이디) / Caret position information in document (list ID) pub list_id: UINT32, /// 문단 아이디 / Paragraph ID pub paragraph_id: UINT32, /// 문단 내에서의 글자 단위 위치 / Character position within paragraph pub character_position: UINT32, } impl DocumentProperties { /// DocumentProperties를 바이트 배열에서 파싱합니다. / Parse DocumentProperties from byte array. /// /// # Arguments /// * `data` - 최소 26바이트의 데이터 / At least 26 bytes of data /// /// # Returns /// 파싱된 DocumentProperties 구조체 / Parsed DocumentProperties structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // 레거시 코드 기준으로 26바이트를 읽음 // Read 26 bytes based on legacy code if data.len() < 26 { return Err(HwpError::insufficient_data("DocumentProperties", 26, data.len())); } let mut offset = 0; // UINT16 구역 개수 / UINT16 area count let area_count = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT16 페이지 시작 번호 / UINT16 page start number // Note: 레거시 코드에서는 "문서 내 각종 시작번호에 대한 정보" 필드를 건너뛰고 바로 페이지 시작 번호를 읽음 // Note: Legacy code skips "start number information" field and reads page_start_number directly let page_start_number = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT16 각주 시작 번호 / UINT16 footnote start number let footnote_start_number = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT16 미주 시작 번호 / UINT16 endnote start number let endnote_start_number = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT16 그림 시작 번호 / UINT16 image start number let image_start_number = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT16 표 시작 번호 / UINT16 table start number let table_start_number = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT16 수식 시작 번호 / UINT16 formula start number let formula_start_number = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT32 문서 내 캐럿의 위치 정보 (리스트 아이디) / UINT32 caret position (list ID) let list_id = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // UINT32 문단 아이디 / UINT32 paragraph ID let paragraph_id = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // UINT32 문단 내에서의 글자 단위 위치 / UINT32 character position within paragraph let character_position = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); Ok(DocumentProperties { area_count, start_number_info: 0, // 레거시 코드에서는 이 필드를 건너뜀 / This field is skipped in legacy code page_start_number, footnote_start_number, endnote_start_number, image_start_number, table_start_number, formula_start_number, list_id, paragraph_id, character_position, }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/tab_def.rs	crates/hwp-core/src/document/docinfo/tab_def.rs	/// Tab Definition 구조체 / Tab Definition structure /// /// 스펙 문서 매핑: 표 36 - 탭 정의 / Spec mapping: Table 36 - Tab definition /// Tag ID: HWPTAG_TAB_DEF /// 전체 길이: 가변 (8 + 8×count 바이트) / Total length: variable (8 + 8×count bytes) use crate::error::HwpError; use crate::types::{HWPUNIT, INT16, UINT32, UINT8}; use serde::{Deserialize, Serialize}; /// 탭 종류 / Tab type #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum TabType { /// 왼쪽 / Left Left = 0, /// 오른쪽 / Right Right = 1, /// 가운데 / Center Center = 2, /// 소수점 / Decimal Decimal = 3, } impl TabType { /// UINT8 값에서 TabType 생성 / Create TabType from UINT8 value fn from_byte(value: UINT8) -> Self { match value { 1 => TabType::Right, 2 => TabType::Center, 3 => TabType::Decimal, _ => TabType::Left, } } } /// 탭 정의 속성 / Tab definition attributes #[derive(Debug, Clone, Serialize, Deserialize)] pub struct TabDefAttributes { /// 문단 왼쪽 끝 자동 탭(내어 쓰기용 자동 탭) 유무 / Auto tab at paragraph left edge (hanging indent) pub has_left_auto_tab: bool, /// 문단 오른쪽 끝 자동 탭 유무 / Auto tab at paragraph right edge pub has_right_auto_tab: bool, } /// 탭 항목 / Tab item #[derive(Debug, Clone, Serialize, Deserialize)] pub struct TabItem { /// 탭의 위치 / Tab position pub position: HWPUNIT, /// 탭의 종류 / Tab type pub tab_type: TabType, /// 채움 종류 (표 25 참조) / Fill type (Table 25) pub fill_type: UINT8, } /// Tab Definition 구조체 / Tab Definition structure #[derive(Debug, Clone, Serialize, Deserialize)] pub struct TabDef { /// 속성 (표 37) / Attributes (Table 37) pub attributes: TabDefAttributes, /// 탭 개수 / Tab count pub count: INT16, /// 탭 항목 목록 / Tab items list pub tabs: Vec<TabItem>, } impl TabDef { /// TabDef를 바이트 배열에서 파싱합니다. / Parse TabDef from byte array. /// /// # Arguments /// * `data` - TabDef 레코드 데이터 / TabDef record data /// /// # Returns /// 파싱된 TabDef 구조체 / Parsed TabDef structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // 최소 6바이트 필요 (속성 4바이트 + count 2바이트) / Need at least 6 bytes (attributes 4 bytes + count 2 bytes) if data.len() < 6 { return Err(HwpError::insufficient_data("TabDef", 6, data.len())); } let mut offset = 0; // UINT32 속성 (표 37) / UINT32 attributes (Table 37) let attr_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let attributes = TabDefAttributes { has_left_auto_tab: (attr_value & 0x00000001) != 0, has_right_auto_tab: (attr_value & 0x00000002) != 0, }; // INT16 count / INT16 count let count = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // 탭 항목 파싱 (각 8바이트) / Parse tab items (8 bytes each) let mut tabs = Vec::new(); for _ in 0..count { if offset + 8 > data.len() { return Err(HwpError::InsufficientData { field: format!("TabDef tab item at offset {}", offset), expected: offset + 8, actual: data.len(), }); } // HWPUNIT 탭의 위치 / HWPUNIT tab position let position = HWPUNIT(u32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; // UINT8 탭의 종류 / UINT8 tab type let tab_type = TabType::from_byte(data[offset]); offset += 1; // UINT8 채움 종류 / UINT8 fill type let fill_type = data[offset]; offset += 1; // UINT16 예약 (8바이트 맞춤용) / UINT16 reserved (for 8-byte alignment) offset += 2; tabs.push(TabItem { position, tab_type, fill_type, }); } Ok(TabDef { attributes, count, tabs, }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/char_shape.rs	crates/hwp-core/src/document/docinfo/char_shape.rs	/// Character Shape 구조체 / Character Shape structure /// /// 스펙 문서 매핑: 표 33 - 글자 모양 / Spec mapping: Table 33 - Character shape /// Tag ID: HWPTAG_CHAR_SHAPE /// 전체 길이: 72 바이트 / Total length: 72 bytes use crate::error::HwpError; use crate::types::{COLORREF, INT32, INT8, UINT16, UINT32, UINT8, WORD}; use serde::{Deserialize, Serialize}; /// 언어별 글꼴 정보 / Language-specific font information #[derive(Debug, Clone, Serialize, Deserialize)] pub struct LanguageFontInfo { /// 한글 글꼴 ID / Korean font ID pub korean: WORD, /// 영어 글꼴 ID / English font ID pub english: WORD, /// 한자 글꼴 ID / Chinese font ID pub chinese: WORD, /// 일어 글꼴 ID / Japanese font ID pub japanese: WORD, /// 기타 글꼴 ID / Other font ID pub other: WORD, /// 기호 글꼴 ID / Symbol font ID pub symbol: WORD, /// 사용자 글꼴 ID / User font ID pub user: WORD, } /// 언어별 글자 속성 정보 (UINT8) / Language-specific character attribute information (UINT8) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct LanguageCharAttributesU8 { /// 한글 / Korean pub korean: UINT8, /// 영어 / English pub english: UINT8, /// 한자 / Chinese pub chinese: UINT8, /// 일어 / Japanese pub japanese: UINT8, /// 기타 / Other pub other: UINT8, /// 기호 / Symbol pub symbol: UINT8, /// 사용자 / User pub user: UINT8, } /// 언어별 글자 속성 정보 (INT8) / Language-specific character attribute information (INT8) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct LanguageCharAttributesI8 { /// 한글 / Korean pub korean: INT8, /// 영어 / English pub english: INT8, /// 한자 / Chinese pub chinese: INT8, /// 일어 / Japanese pub japanese: INT8, /// 기타 / Other pub other: INT8, /// 기호 / Symbol pub symbol: INT8, /// 사용자 / User pub user: INT8, } /// 글자 모양 속성 / Character shape attributes #[derive(Debug, Clone, Serialize, Deserialize)] pub struct CharShapeAttributes { /// 기울임 여부 / Italic pub italic: bool, /// 진하게 여부 / Bold pub bold: bool, /// 밑줄 종류 (0: 없음, 1: 글자 아래, 2: 글자 위) / Underline type (0: none, 1: below, 2: above) pub underline_type: UINT8, // bits 2-3 /// 밑줄 모양 (0-6) / Underline style (0-6) pub underline_style: UINT8, // bits 4-7 /// 외곽선 종류 (0: 없음, 1: 비연속, 2: 연속) / Outline type (0: none, 1: non-continuous, 2: continuous) pub outline_type: UINT8, // bits 8-10 /// 그림자 종류 / Shadow type pub shadow_type: UINT8, // bits 11-12 /// 양각 여부 / Emboss pub emboss: bool, // bit 13 /// 음각 여부 / Engrave pub engrave: bool, // bit 14 /// 위 첨자 여부 / Superscript pub superscript: bool, // bit 15 /// 아래 첨자 여부 / Subscript pub subscript: bool, // bit 16 /// 취소선 여부 (0: 없음, 1 이상: 있음) / Strikethrough (0: none, 1+: present) /// 스펙 문서 표 35: bit 18-20 / Spec Table 35: bit 18-20 pub strikethrough: UINT8, /// 강조점 종류 / Emphasis mark type pub emphasis_mark: UINT8, // bits 21-24 /// 글꼴에 어울리는 빈칸 사용 여부 / Use font-appropriate spacing pub use_font_spacing: bool, // bit 25 /// 취소선 모양 (표 25 참조) / Strikethrough style (Table 25) pub strikethrough_style: UINT8, // bits 26-29 /// Kerning 여부 / Kerning pub kerning: bool, // bit 30 } /// Character Shape 구조체 / Character Shape structure #[derive(Debug, Clone, Serialize, Deserialize)] pub struct CharShape { /// 언어별 글꼴 ID (표 34) / Language-specific font IDs (Table 34) pub font_ids: LanguageFontInfo, /// 언어별 장평, 50%~200% / Language-specific font stretch, 50%~200% pub font_stretch: LanguageCharAttributesU8, /// 언어별 자간, -50%~50% / Language-specific letter spacing, -50%~50% pub letter_spacing: LanguageCharAttributesI8, /// 언어별 상대 크기, 10%~250% / Language-specific relative size, 10%~250% pub relative_size: LanguageCharAttributesU8, /// 언어별 글자 위치, -100%~100% / Language-specific text position, -100%~100% pub text_position: LanguageCharAttributesI8, /// 기준 크기, 0pt~4096pt / Base size, 0pt~4096pt pub base_size: INT32, /// 속성 (표 35) / Attributes (Table 35) pub attributes: CharShapeAttributes, /// 그림자 간격 X, -100%~100% / Shadow spacing X, -100%~100% pub shadow_spacing_x: INT8, /// 그림자 간격 Y, -100%~100% / Shadow spacing Y, -100%~100% pub shadow_spacing_y: INT8, /// 글자 색 / Text color pub text_color: COLORREF, /// 밑줄 색 / Underline color pub underline_color: COLORREF, /// 음영 색 / Shading color pub shading_color: COLORREF, /// 그림자 색 / Shadow color pub shadow_color: COLORREF, /// 글자 테두리/배경 ID (5.0.2.1 이상) / Character border/fill ID (5.0.2.1 and above) pub border_fill_id: Option<UINT16>, /// 취소선 색 (5.0.3.0 이상) / Strikethrough color (5.0.3.0 and above) pub strikethrough_color: Option<COLORREF>, } impl CharShape { /// CharShape를 바이트 배열에서 파싱합니다. / Parse CharShape from byte array. /// /// # Arguments /// * `data` - 최소 66바이트의 데이터 (기본 66바이트, 버전에 따라 최대 72바이트) / At least 66 bytes of data (basic 66 bytes, up to 72 bytes depending on version) /// * `version` - FileHeader의 version (버전에 따라 필드 개수가 다를 수 있음) / FileHeader version (field count may vary by version) /// /// # Returns /// 파싱된 CharShape 구조체 / Parsed CharShape structure pub fn parse(data: &[u8], _version: u32) -> Result<Self, HwpError> { // 최소 66바이트 필요 / Need at least 66 bytes if data.len() < 66 { return Err(HwpError::insufficient_data("CharShape", 66, data.len())); } let mut offset = 0; // WORD array[7] 언어별 글꼴 ID / WORD array[7] language-specific font IDs let font_ids = LanguageFontInfo { korean: WORD::from_le_bytes([data[offset], data[offset + 1]]), english: WORD::from_le_bytes([data[offset + 2], data[offset + 3]]), chinese: WORD::from_le_bytes([data[offset + 4], data[offset + 5]]), japanese: WORD::from_le_bytes([data[offset + 6], data[offset + 7]]), other: WORD::from_le_bytes([data[offset + 8], data[offset + 9]]), symbol: WORD::from_le_bytes([data[offset + 10], data[offset + 11]]), user: WORD::from_le_bytes([data[offset + 12], data[offset + 13]]), }; offset += 14; // UINT8 array[7] 언어별 장평 / UINT8 array[7] language-specific font stretch let font_stretch = LanguageCharAttributesU8 { korean: data[offset] as UINT8, english: data[offset + 1] as UINT8, chinese: data[offset + 2] as UINT8, japanese: data[offset + 3] as UINT8, other: data[offset + 4] as UINT8, symbol: data[offset + 5] as UINT8, user: data[offset + 6] as UINT8, }; offset += 7; // INT8 array[7] 언어별 자간 / INT8 array[7] language-specific letter spacing // u8을 i8로 캐스팅할 때 부호 확장이 제대로 되도록 i8::from_le_bytes 사용 // Use i8::from_le_bytes to properly handle sign extension when casting u8 to i8 let letter_spacing = LanguageCharAttributesI8 { korean: i8::from_le_bytes([data[offset]]), english: i8::from_le_bytes([data[offset + 1]]), chinese: i8::from_le_bytes([data[offset + 2]]), japanese: i8::from_le_bytes([data[offset + 3]]), other: i8::from_le_bytes([data[offset + 4]]), symbol: i8::from_le_bytes([data[offset + 5]]), user: i8::from_le_bytes([data[offset + 6]]), }; offset += 7; // UINT8 array[7] 언어별 상대 크기 / UINT8 array[7] language-specific relative size let relative_size = LanguageCharAttributesU8 { korean: data[offset] as UINT8, english: data[offset + 1] as UINT8, chinese: data[offset + 2] as UINT8, japanese: data[offset + 3] as UINT8, other: data[offset + 4] as UINT8, symbol: data[offset + 5] as UINT8, user: data[offset + 6] as UINT8, }; offset += 7; // INT8 array[7] 언어별 글자 위치 / INT8 array[7] language-specific text position // u8을 i8로 캐스팅할 때 부호 확장이 제대로 되도록 i8::from_le_bytes 사용 // Use i8::from_le_bytes to properly handle sign extension when casting u8 to i8 let text_position = LanguageCharAttributesI8 { korean: i8::from_le_bytes([data[offset]]), english: i8::from_le_bytes([data[offset + 1]]), chinese: i8::from_le_bytes([data[offset + 2]]), japanese: i8::from_le_bytes([data[offset + 3]]), other: i8::from_le_bytes([data[offset + 4]]), symbol: i8::from_le_bytes([data[offset + 5]]), user: i8::from_le_bytes([data[offset + 6]]), }; offset += 7; // INT32 기준 크기 / INT32 base size let base_size = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // UINT32 속성 (표 35) / UINT32 attributes (Table 35) let attr_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // UINT32 속성 파싱 (표 35) / Parse UINT32 attributes (Table 35) let attributes = CharShapeAttributes { italic: (attr_value & 0x00000001) != 0, bold: (attr_value & 0x00000002) != 0, underline_type: ((attr_value >> 2) & 0x03) as UINT8, underline_style: ((attr_value >> 4) & 0x0F) as UINT8, outline_type: ((attr_value >> 8) & 0x07) as UINT8, shadow_type: ((attr_value >> 11) & 0x03) as UINT8, emboss: (attr_value & 0x00002000) != 0, engrave: (attr_value & 0x00004000) != 0, superscript: (attr_value & 0x00008000) != 0, subscript: (attr_value & 0x00010000) != 0, strikethrough: ((attr_value >> 18) & 0x07) as UINT8, // bit 18-20: 취소선 여부 (표 35) / bit 18-20: Strikethrough (Table 35) emphasis_mark: ((attr_value >> 21) & 0x0F) as UINT8, use_font_spacing: (attr_value & 0x02000000) != 0, strikethrough_style: ((attr_value >> 26) & 0x0F) as UINT8, kerning: (attr_value & 0x40000000) != 0, }; // INT8 그림자 간격 X / INT8 shadow spacing X let shadow_spacing_x = data[offset] as INT8; offset += 1; // INT8 그림자 간격 Y / INT8 shadow spacing Y let shadow_spacing_y = data[offset] as INT8; offset += 1; // COLORREF 글자 색 / COLORREF text color let text_color = COLORREF(u32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; // COLORREF 밑줄 색 / COLORREF underline color let underline_color = COLORREF(u32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; // COLORREF 음영 색 / COLORREF shading color let shading_color = COLORREF(u32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; // COLORREF 그림자 색 / COLORREF shadow color let shadow_color = COLORREF(u32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; // UINT16 글자 테두리/배경 ID (5.0.2.1 이상) / UINT16 character border/fill ID (5.0.2.1 and above) // 데이터 크기로 판단: 66바이트 이상이면 border_fill_id 필드 존재 / Determine by data size: border_fill_id exists if 66 bytes or more let border_fill_id = if data.len() >= 66 && offset + 2 <= data.len() { Some(WORD::from_le_bytes([data[offset], data[offset + 1]])) } else { None }; if border_fill_id.is_some() { offset += 2; } // COLORREF 취소선 색 (5.0.3.0 이상) / COLORREF strikethrough color (5.0.3.0 and above) // 데이터 크기로 판단: 70바이트 이상이면 strikethrough_color 필드 존재 / Determine by data size: strikethrough_color exists if 70 bytes or more let strikethrough_color = if data.len() >= 70 && offset + 4 <= data.len() { Some(COLORREF(u32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]))) } else { None }; Ok(CharShape { font_ids, font_stretch, letter_spacing, relative_size, text_position, base_size, attributes, shadow_spacing_x, shadow_spacing_y, text_color, underline_color, shading_color, shadow_color, border_fill_id, strikethrough_color, }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/border_fill.rs	crates/hwp-core/src/document/docinfo/border_fill.rs	/// Border/Fill 구조체 / Border/Fill structure /// /// 스펙 문서 매핑: 표 23 - 테두리/배경 속성 / Spec mapping: Table 23 - Border/fill properties /// Tag ID: HWPTAG_BORDER_FILL use crate::error::HwpError; use crate::types::{BYTE, COLORREF, INT16, INT32, UINT, UINT16, UINT8}; use serde::{Deserialize, Serialize}; /// 테두리선 정보 / Border line information #[derive(Debug, Clone, Serialize, Deserialize)] pub struct BorderLine { /// 테두리선 종류 (표 25) / Border line type (Table 25) pub line_type: UINT8, /// 테두리선 굵기 (표 26) / Border line width (Table 26) pub width: UINT8, /// 테두리선 색상 / Border line color pub color: COLORREF, } /// 대각선 정보 / Diagonal line information #[derive(Debug, Clone, Serialize, Deserialize)] pub struct DiagonalLine { /// 대각선 종류 (표 27) / Diagonal line type (Table 27) pub line_type: UINT8, /// 대각선 굵기 / Diagonal line thickness pub thickness: UINT8, /// 대각선 색상 / Diagonal line color pub color: COLORREF, } /// 채우기 종류 / Fill type #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "UPPERCASE")] pub enum FillType { /// 채우기 없음 / No fill None = 0x00000000, /// 단색 채우기 / Solid fill Solid = 0x00000001, /// 이미지 채우기 / Image fill Image = 0x00000002, /// 그러데이션 채우기 / Gradient fill Gradient = 0x00000004, } /// 단색 채우기 정보 / Solid fill information #[derive(Debug, Clone, Serialize, Deserialize)] pub struct SolidFill { /// 배경색 / Background color pub background_color: COLORREF, /// 무늬색 / Pattern color pub pattern_color: COLORREF, /// 무늬 종류 (표 29) / Pattern type (Table 29) pub pattern_type: INT32, } /// 그러데이션 채우기 정보 / Gradient fill information #[derive(Debug, Clone, Serialize, Deserialize)] pub struct GradientFill { /// 그러데이션 유형 (표 30) / Gradient type (Table 30) pub gradient_type: INT16, /// 그러데이션의 기울임(시작 각) / Gradient angle (start angle) pub angle: INT16, /// 그러데이션의 가로 중심(중심 X 좌표) / Gradient horizontal center (center X coordinate) pub horizontal_center: INT16, /// 그러데이션의 세로 중심(중심 Y 좌표) / Gradient vertical center (center Y coordinate) pub vertical_center: INT16, /// 그러데이션 번짐 정도(0-100) / Gradient spread (0-100) pub spread: INT16, /// 그러데이션의 색 수 / Number of gradient colors pub color_count: INT16, /// 색상이 바뀌는 곳의 위치 (color_count > 2일 경우에만) / Color change positions (only if color_count > 2) pub positions: Option<Vec<INT32>>, /// 색상 배열 / Color array pub colors: Vec<COLORREF>, } /// 이미지 채우기 정보 / Image fill information #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ImageFill { /// 이미지 채우기 유형 (표 31) / Image fill type (Table 31) pub image_fill_type: BYTE, /// 그림 정보 (표 32) / Image information (Table 32) pub image_info: Vec<u8>, // 5 bytes /// 그러데이션 번짐정도의 중심 (0..100) / Gradient spread center (0..100) pub gradient_spread_center: Option<BYTE>, /// 추가 채우기 속성 길이 / Additional fill attribute length pub additional_attributes_length: Option<UINT>, /// 추가 채우기 속성 / Additional fill attributes pub additional_attributes: Option<Vec<u8>>, } /// 채우기 정보 / Fill information #[derive(Debug, Clone, Serialize, Deserialize)] #[serde(tag = "type", rename_all = "lowercase")] #[allow(dead_code)] pub enum FillInfo { /// 채우기 없음 / No fill None, /// 단색 채우기 / Solid fill Solid(SolidFill), /// 이미지 채우기 / Image fill Image(ImageFill), /// 그러데이션 채우기 / Gradient fill Gradient(GradientFill), } /// 테두리/배경 속성 / Border/fill properties #[derive(Debug, Clone, Serialize, Deserialize)] pub struct BorderFill { /// 속성 (표 24) / Attributes (Table 24) pub attributes: BorderFillAttributes, /// 4방향 테두리선 정보 / 4-direction border line information pub borders: [BorderLine; 4], // [Left, Right, Top, Bottom] /// 대각선 정보 / Diagonal line information pub diagonal: DiagonalLine, /// 채우기 정보 / Fill information pub fill: FillInfo, } /// 테두리/배경 속성 비트 플래그 / Border/fill attribute bit flags #[derive(Debug, Clone, Serialize, Deserialize)] pub struct BorderFillAttributes { /// 3D 효과의 유무 / 3D effect presence pub has_3d_effect: bool, /// 그림자 효과의 유무 / Shadow effect presence pub has_shadow: bool, /// Slash 대각선 모양 / Slash diagonal shape pub slash_shape: u8, // bits 2-4 /// BackSlash 대각선 모양 / BackSlash diagonal shape pub backslash_shape: u8, // bits 5-7 /// Slash 대각선 꺽은선 / Slash diagonal broken line pub slash_broken_line: u8, // bits 8-9 /// BackSlash 대각선 꺽은선 / BackSlash diagonal broken line pub backslash_broken_line: bool, // bit 10 /// Slash 대각선 모양 180도 회전 여부 / Slash diagonal 180 degree rotation pub slash_rotated_180: bool, // bit 11 /// BackSlash 대각선 모양 180도 회전 여부 / BackSlash diagonal 180 degree rotation pub backslash_rotated_180: bool, // bit 12 /// 중심선 유무 / Center line presence pub has_center_line: bool, // bit 13 } impl BorderFill { /// BorderFill을 바이트 배열에서 파싱합니다. / Parse BorderFill from byte array. /// /// # Arguments /// * `data` - BorderFill 레코드 데이터 / BorderFill record data /// /// # Returns /// 파싱된 BorderFill 구조체 / Parsed BorderFill structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 32 { return Err(HwpError::insufficient_data("BorderFill", 32, data.len())); } let mut offset = 0; // UINT16 속성 (표 24) / UINT16 attributes (Table 24) let attr_value = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let attributes = BorderFillAttributes { has_3d_effect: (attr_value & 0x0001) != 0, has_shadow: (attr_value & 0x0002) != 0, slash_shape: ((attr_value >> 2) & 0x07) as u8, backslash_shape: ((attr_value >> 5) & 0x07) as u8, slash_broken_line: ((attr_value >> 8) & 0x03) as u8, backslash_broken_line: (attr_value & 0x0400) != 0, slash_rotated_180: (attr_value & 0x0800) != 0, backslash_rotated_180: (attr_value & 0x1000) != 0, has_center_line: (attr_value & 0x2000) != 0, }; // NOTE: // BorderFill의 실제 저장 포맷은 구현체/버전에 따라 2가지가 관찰됨. // (A) 스펙(표 23): line_types[4] -> widths[4] -> colors[4] // (B) 레거시(hwpjs.js): (line_type, width, color) * 4 (Left, Right, Top, Bottom) interleave // 여기서는 둘 다 파싱해보고 “더 그럴듯한” 결과를 선택한다. if data.len() < offset + 24 + 1 + 1 + 4 { return Err(HwpError::insufficient_data( "BorderFill (borders+diagonal)", offset + 24 + 1 + 1 + 4, data.len(), )); } fn score_borderline(line: &BorderLine) -> i32 { let mut s = 0; // width는 표 26: 0..=15 if line.width <= 15 { s += 3; } else { s -= 10; } // line_type는 표 25: 0..=16 (실무에서 확장값이 있을 수 있어 약간 완화) if line.line_type <= 32 { s += 2; } else { s -= 5; } // color는 COLORREF이므로 어떤 값이든 가능하지만, 0xFFFFFFFF 같은 극단값은 감점 if line.color.0 == 0xFFFFFFFF { s -= 2; } s } fn score_borders(borders: &[BorderLine; 4]) -> i32 { borders.iter().map(score_borderline).sum() } let start = offset; // (B) interleave: (line, width, color) * 4 let mut borders_interleave: [BorderLine; 4] = [ BorderLine { line_type: 0, width: 0, color: COLORREF(0), }, BorderLine { line_type: 0, width: 0, color: COLORREF(0), }, BorderLine { line_type: 0, width: 0, color: COLORREF(0), }, BorderLine { line_type: 0, width: 0, color: COLORREF(0), }, ]; let mut off_i = start; for i in 0..4 { let line_type = data[off_i]; off_i += 1; let width = data[off_i]; off_i += 1; let color = COLORREF(u32::from_le_bytes([ data[off_i], data[off_i + 1], data[off_i + 2], data[off_i + 3], ])); off_i += 4; borders_interleave[i] = BorderLine { line_type, width, color, }; } // (A) spec arrays: line_types[4], widths[4], colors[4] let mut borders_spec: [BorderLine; 4] = borders_interleave.clone(); let mut off_s = start; let line_types = [ data[off_s], data[off_s + 1], data[off_s + 2], data[off_s + 3], ]; off_s += 4; let widths = [ data[off_s], data[off_s + 1], data[off_s + 2], data[off_s + 3], ]; off_s += 4; let mut colors = [COLORREF(0); 4]; for i in 0..4 { colors[i] = COLORREF(u32::from_le_bytes([ data[off_s], data[off_s + 1], data[off_s + 2], data[off_s + 3], ])); off_s += 4; } for i in 0..4 { borders_spec[i] = BorderLine { line_type: line_types[i], width: widths[i], color: colors[i], }; } // 점수 비교로 선택 let score_i = score_borders(&borders_interleave); let score_s = score_borders(&borders_spec); let borders = if score_i >= score_s { offset = off_i; borders_interleave } else { offset = off_s; borders_spec }; // debug instrumentation removed // UINT8 대각선 종류 / UINT8 diagonal line type let diagonal_type = data[offset]; offset += 1; // UINT8 대각선 굵기 / UINT8 diagonal line thickness let diagonal_thickness = data[offset]; offset += 1; // COLORREF 대각선 색깔 / COLORREF diagonal line color let diagonal_color = COLORREF(u32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; let diagonal = DiagonalLine { line_type: diagonal_type, thickness: diagonal_thickness, color: diagonal_color, }; // BYTE stream 채우기 정보 (표 28) / BYTE stream fill information (Table 28) let fill = if offset < data.len() { Self::parse_fill_info(&data[offset..])? } else { FillInfo::None }; Ok(BorderFill { attributes, borders, diagonal, fill, }) } /// 채우기 정보 파싱 / Parse fill information fn parse_fill_info(data: &[u8]) -> Result<FillInfo, HwpError> { if data.len() < 4 { return Ok(FillInfo::None); } let mut offset = 0; // UINT 채우기 종류 / UINT fill type let fill_type_value = UINT::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let fill_type = if fill_type_value == 0x00000000 { FillType::None } else if (fill_type_value & 0x00000001) != 0 { FillType::Solid } else if (fill_type_value & 0x00000002) != 0 { FillType::Image } else if (fill_type_value & 0x00000004) != 0 { FillType::Gradient } else { return Ok(FillInfo::None); }; match fill_type { FillType::None => Ok(FillInfo::None), FillType::Solid => { if offset + 12 > data.len() { return Err(HwpError::insufficient_data( "Solid fill data", 12, data.len() - offset, )); } let background_color = COLORREF(u32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; let pattern_color = COLORREF(u32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; let pattern_type = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); Ok(FillInfo::Solid(SolidFill { background_color, pattern_color, pattern_type, })) } FillType::Gradient => { if offset + 12 > data.len() { return Err(HwpError::insufficient_data( "Gradient fill data", 12, data.len() - offset, )); } let gradient_type = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let angle = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let horizontal_center = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let vertical_center = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let spread = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let color_count = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let positions = if color_count > 2 { if offset + (4 * color_count as usize) > data.len() { return Err(HwpError::insufficient_data( "Gradient positions data", 4 * color_count as usize, data.len() - offset, )); } let mut pos_vec = Vec::new(); for _ in 0..color_count { pos_vec.push(INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; } Some(pos_vec) } else { None }; if offset + (4 * color_count as usize) > data.len() { return Err(HwpError::insufficient_data( "Gradient colors data", 4 * color_count as usize, data.len() - offset, )); } let mut colors = Vec::new(); for _ in 0..color_count { colors.push(COLORREF(u32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]))); offset += 4; } Ok(FillInfo::Gradient(GradientFill { gradient_type, angle, horizontal_center, vertical_center, spread, color_count, positions, colors, })) } FillType::Image => { // 이미지 채우기는 복잡하므로 기본 구조만 파싱 / Image fill is complex, so only parse basic structure if offset + 1 > data.len() { return Err(HwpError::insufficient_data( "Image fill type", 1, data.len() - offset, )); } let image_fill_type = data[offset]; offset += 1; if offset + 5 > data.len() { return Err(HwpError::insufficient_data( "Image info", 5, data.len() - offset, )); } let image_info = data[offset..offset + 5].to_vec(); offset += 5; // 나머지는 복잡하므로 일단 기본 구조만 / Rest is complex, so only basic structure for now Ok(FillInfo::Image(ImageFill { image_fill_type, image_info, gradient_spread_center: None, additional_attributes_length: None, additional_attributes: None, })) } } } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/face_name.rs	crates/hwp-core/src/document/docinfo/face_name.rs	/// Face Name (Font) 구조체 / Face Name (Font) structure /// /// 스펙 문서 매핑: 표 19 - 글꼴 / Spec mapping: Table 19 - Font /// Tag ID: HWPTAG_FACE_NAME use crate::error::HwpError; use crate::types::{decode_utf16le, BYTE, WORD}; use serde::{Deserialize, Serialize}; /// 글꼴 속성 플래그 / Font attribute flags mod flags { /// 대체 글꼴 존재 여부 / Alternative font exists pub const HAS_ALTERNATIVE: u8 = 0x80; /// 글꼴 유형 정보 존재 여부 / Font type information exists pub const HAS_TYPE_INFO: u8 = 0x40; /// 기본 글꼴 존재 여부 / Default font exists pub const HAS_DEFAULT: u8 = 0x20; } /// 대체 글꼴 유형 / Alternative font type #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "UPPERCASE")] pub enum AlternativeFontType { /// 원래 종류를 알 수 없을 때 / Unknown original type Unknown = 0, /// 트루타입 글꼴(TTF) / TrueType font (TTF) TTF = 1, /// 한글 전용 글꼴(HFT) / HWP font (HFT) HFT = 2, } impl AlternativeFontType { /// BYTE 값에서 AlternativeFontType 생성 / Create AlternativeFontType from BYTE value fn from_byte(value: BYTE) -> Self { match value { 1 => AlternativeFontType::TTF, 2 => AlternativeFontType::HFT, _ => AlternativeFontType::Unknown, } } } /// 글꼴 유형 정보 / Font type information #[derive(Debug, Clone, Serialize, Deserialize)] pub struct FontTypeInfo { /// 글꼴 계열 / Font family pub font_family: BYTE, /// 세리프 유형 / Serif type pub serif: BYTE, /// 굵기 / Boldness pub bold: BYTE, /// 비례 / Proportion pub proportion: BYTE, /// 대조 / Contrast pub contrast: BYTE, /// 스트로크 편차 / Stroke variation pub stroke_variation: BYTE, /// 자획 유형 / Stroke type pub stroke_type: BYTE, /// 글자형 / Letter type pub letter_type: BYTE, /// 중간선 / Middle line pub middle_line: BYTE, /// X-높이 / X-height pub x_height: BYTE, } /// Face Name (Font) 구조체 / Face Name (Font) structure #[derive(Debug, Clone, Serialize, Deserialize)] pub struct FaceName { /// 글꼴 이름 / Font name pub name: String, /// 대체 글꼴 유형 (속성에 따라 존재) / Alternative font type (exists based on attribute) pub alternative_font_type: Option<AlternativeFontType>, /// 대체 글꼴 이름 (속성에 따라 존재) / Alternative font name (exists based on attribute) pub alternative_font_name: Option<String>, /// 글꼴 유형 정보 (속성에 따라 존재) / Font type information (exists based on attribute) pub font_type_info: Option<FontTypeInfo>, /// 기본 글꼴 이름 (속성에 따라 존재) / Default font name (exists based on attribute) pub default_font_name: Option<String>, } impl FaceName { /// FaceName을 바이트 배열에서 파싱합니다. / Parse FaceName from byte array. /// /// # Arguments /// * `data` - FaceName 레코드 데이터 / FaceName record data /// /// # Returns /// 파싱된 FaceName 구조체 / Parsed FaceName structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 3 { return Err(HwpError::insufficient_data("FaceName", 3, data.len())); } let mut offset = 0; // BYTE 속성 (표 20) / BYTE attribute (Table 20) let attributes = data[offset]; offset += 1; // WORD 글꼴 이름 길이 / WORD font name length let name_length = WORD::from_le_bytes([data[offset], data[offset + 1]]) as usize; offset += 2; // WCHAR array 글꼴 이름 / WCHAR array font name if offset + (name_length * 2) > data.len() { return Err(HwpError::InsufficientData { field: format!("FaceName font name at offset {}", offset), expected: offset + (name_length * 2), actual: data.len(), }); } let name_bytes = &data[offset..offset + (name_length * 2)]; let name = decode_utf16le(name_bytes) .map_err(\|e\| HwpError::EncodingError { reason: format!("Failed to decode font name: {}", e), })?; offset += name_length * 2; // 대체 글꼴 처리 (속성 bit 7이 1인 경우) / Process alternative font (if attribute bit 7 is 1) let (alternative_font_type, alternative_font_name) = if (attributes & flags::HAS_ALTERNATIVE) != 0 { if offset >= data.len() { return Err(HwpError::insufficient_data( "FaceName alternative font type", 1, 0, )); } let alt_type_byte = data[offset]; offset += 1; // WORD 대체 글꼴 이름 길이 / WORD alternative font name length if offset + 2 > data.len() { return Err(HwpError::insufficient_data( "FaceName alternative font name length", 2, data.len() - offset, )); } let alt_name_length = WORD::from_le_bytes([data[offset], data[offset + 1]]) as usize; offset += 2; // WCHAR array 대체 글꼴 이름 / WCHAR array alternative font name if offset + (alt_name_length * 2) > data.len() { return Err(HwpError::InsufficientData { field: format!("FaceName alternative font name at offset {}", offset), expected: offset + (alt_name_length * 2), actual: data.len(), }); } let alt_name_bytes = &data[offset..offset + (alt_name_length * 2)]; let alt_name = decode_utf16le(alt_name_bytes) .map_err(\|e\| HwpError::EncodingError { reason: format!("Failed to decode alternative font name: {}", e), })?; offset += alt_name_length * 2; ( Some(AlternativeFontType::from_byte(alt_type_byte)), Some(alt_name), ) } else { (None, None) }; // 글꼴 유형 정보 처리 (속성 bit 6이 1인 경우) / Process font type info (if attribute bit 6 is 1) let font_type_info = if (attributes & flags::HAS_TYPE_INFO) != 0 { if offset + 10 > data.len() { return Err(HwpError::insufficient_data( "FaceName font type info", 10, data.len() - offset, )); } Some(FontTypeInfo { font_family: data[offset], serif: data[offset + 1], bold: data[offset + 2], proportion: data[offset + 3], contrast: data[offset + 4], stroke_variation: data[offset + 5], stroke_type: data[offset + 6], letter_type: data[offset + 7], middle_line: data[offset + 8], x_height: data[offset + 9], }) } else { None }; if font_type_info.is_some() { offset += 10; } // 기본 글꼴 처리 (속성 bit 5가 1인 경우) / Process default font (if attribute bit 5 is 1) let default_font_name = if (attributes & flags::HAS_DEFAULT) != 0 { if offset + 2 > data.len() { return Err(HwpError::insufficient_data( "FaceName default font name length", 2, data.len() - offset, )); } let default_name_length = WORD::from_le_bytes([data[offset], data[offset + 1]]) as usize; offset += 2; if offset + (default_name_length * 2) > data.len() { return Err(HwpError::InsufficientData { field: format!("FaceName default font name at offset {}", offset), expected: offset + (default_name_length * 2), actual: data.len(), }); } let default_name_bytes = &data[offset..offset + (default_name_length * 2)]; let default_name = decode_utf16le(default_name_bytes) .map_err(\|e\| HwpError::EncodingError { reason: format!("Failed to decode default font name: {}", e), })?; Some(default_name) } else { None }; Ok(FaceName { name, alternative_font_type, alternative_font_name, font_type_info, default_font_name, }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/memo_shape.rs	crates/hwp-core/src/document/docinfo/memo_shape.rs	/// MemoShape 구조체 / MemoShape structure /// /// 스펙 문서 매핑: 표 4 - 메모 모양 / Spec mapping: Table 4 - Memo shape /// 상세 구조는 스펙 문서에 명시되지 않음 / Detailed structure not specified in spec use crate::error::HwpError; use serde::{Deserialize, Serialize}; /// 메모 모양 / Memo shape #[derive(Debug, Clone, Serialize, Deserialize)] pub struct MemoShape { /// Raw data (22바이트) / Raw data (22 bytes) #[serde(skip)] pub raw_data: Vec<u8>, } impl MemoShape { /// MemoShape를 바이트 배열에서 파싱합니다. / Parse MemoShape from byte array. /// /// # Arguments /// * `data` - MemoShape 데이터 (22바이트) / MemoShape data (22 bytes) /// /// # Returns /// 파싱된 MemoShape 구조체 / Parsed MemoShape structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 22 { return Err(HwpError::insufficient_data("MemoShape", 22, data.len())); } Ok(MemoShape { raw_data: data[0..22.min(data.len())].to_vec(), }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/bullet.rs	crates/hwp-core/src/document/docinfo/bullet.rs	/// Bullet 구조체 / Bullet structure /// /// 스펙 문서 매핑: 표 42 - 글머리표 / Spec mapping: Table 42 - Bullet /// Tag ID: HWPTAG_BULLET /// 전체 길이: 20바이트 (표 42) 또는 가변 (레거시 코드 기준) / Total length: 20 bytes (Table 42) or variable (legacy code) use crate::error::HwpError; use crate::types::{BYTE, HWPUNIT16, INT32, UINT32, WCHAR}; use serde::{Deserialize, Serialize}; /// 문단 머리 정보 속성 / Paragraph header information attributes /// /// 표 40 참조 / See Table 40 #[derive(Debug, Clone, Serialize, Deserialize)] pub struct BulletHeaderAttributes { /// 문단의 정렬 종류 / Paragraph alignment type pub align_type: BulletAlignType, /// 인스턴스 유사 여부 (bit 2) / Instance-like flag (bit 2) pub instance_like: bool, /// 자동 내어 쓰기 여부 / Auto outdent flag pub auto_outdent: bool, /// 수준별 본문과의 거리 종류 / Distance type from body text by level pub distance_type: BulletDistanceType, } /// 문단 정렬 종류 / Paragraph alignment type #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum BulletAlignType { /// 왼쪽 / Left Left = 0, /// 가운데 / Center Center = 1, /// 오른쪽 / Right Right = 2, } impl BulletAlignType { fn from_bits(bits: u32) -> Self { match bits & 0x00000003 { 1 => BulletAlignType::Center, 2 => BulletAlignType::Right, _ => BulletAlignType::Left, } } } /// 수준별 본문과의 거리 종류 / Distance type from body text by level #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum BulletDistanceType { /// 글자 크기에 대한 상대 비율 / Relative ratio to font size Ratio = 0, /// 값 / Value Value = 1, } impl BulletDistanceType { fn from_bit(bit: bool) -> Self { if bit { BulletDistanceType::Value } else { BulletDistanceType::Ratio } } } /// 이미지 글머리표 속성 / Image bullet attributes #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ImageBulletAttributes { /// 명암 / Brightness pub brightness: BYTE, /// 밝기 / Contrast pub contrast: BYTE, /// 효과 / Effect pub effect: BYTE, /// ID / ID pub id: BYTE, } /// Bullet 구조체 / Bullet structure #[derive(Debug, Clone, Serialize, Deserialize)] pub struct Bullet { /// 속성 (표 40) / Attributes (Table 40) pub attributes: BulletHeaderAttributes, /// 너비 보정값 / Width correction value pub width: HWPUNIT16, /// 본문과의 거리 / Distance from body text pub space: HWPUNIT16, /// 글자 모양 아이디 참조 / Character shape ID reference pub char_shape_id: INT32, /// 글머리표 문자 / Bullet character pub bullet_char: WCHAR, /// 이미지 글머리표 존재 여부(ID) / Image bullet existence (ID) pub image_bullet_id: INT32, /// 이미지 글머리표 속성 (명암, 밝기, 효과, ID) / Image bullet attributes (brightness, contrast, effect, ID) pub image_bullet_attributes: Option<ImageBulletAttributes>, /// 체크 글머리표 문자 / Check bullet character pub check_bullet_char: WCHAR, } impl Bullet { /// Bullet을 바이트 배열에서 파싱합니다. / Parse Bullet from byte array. /// /// # Arguments /// * `data` - Bullet 레코드 데이터 / Bullet record data /// /// # Returns /// 파싱된 Bullet 구조체 / Parsed Bullet structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // 레거시 코드 기준 최소 12바이트 필요 (속성 4 + 너비 2 + 거리 2 + 글자모양ID 4) / Need at least 12 bytes based on legacy code if data.len() < 12 { return Err(HwpError::insufficient_data("Bullet", 12, data.len())); } let mut offset = 0; // UINT 속성 (표 40) - 레거시 코드 기준 / UINT attributes (Table 40) - based on legacy code let attr_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let attributes = BulletHeaderAttributes { align_type: BulletAlignType::from_bits(attr_value), instance_like: (attr_value & 0x00000004) != 0, auto_outdent: (attr_value & 0x00000008) != 0, distance_type: BulletDistanceType::from_bit((attr_value & 0x00000010) != 0), }; // HWPUNIT16 너비 보정값 / HWPUNIT16 width correction value let width = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // HWPUNIT16 본문과의 거리 / HWPUNIT16 distance from body text let space = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // INT32 글자 모양 아이디 참조 / INT32 character shape ID reference let char_shape_id = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // WCHAR 글머리표 문자 / WCHAR bullet character let bullet_char = if offset + 2 <= data.len() { WCHAR::from_le_bytes([data[offset], data[offset + 1]]) } else { 0 }; offset += 2; // INT32 이미지 글머리표 존재 여부(ID) - 옵션 / INT32 image bullet existence (ID) - optional let image_bullet_id = if offset + 4 <= data.len() { INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]) } else { 0 }; offset += 4; // BYTE stream 이미지 글머리표 속성 (4바이트) - 옵션 / BYTE stream image bullet attributes (4 bytes) - optional let image_bullet_attributes = if offset + 4 <= data.len() { Some(ImageBulletAttributes { brightness: data[offset], contrast: data[offset + 1], effect: data[offset + 2], id: data[offset + 3], }) } else { None }; offset += 4; // WCHAR 체크 글머리표 문자 - 옵션 / WCHAR check bullet character - optional let check_bullet_char = if offset + 2 <= data.len() { WCHAR::from_le_bytes([data[offset], data[offset + 1]]) } else { 0 }; Ok(Bullet { attributes, width, space, char_shape_id, bullet_char, image_bullet_id, image_bullet_attributes, check_bullet_char, }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/track_change_content.rs	crates/hwp-core/src/document/docinfo/track_change_content.rs	/// TrackChangeContent 구조체 / TrackChangeContent structure /// /// 스펙 문서 매핑: 표 4 - 변경 추적 내용 및 모양 / Spec mapping: Table 4 - Track change content and shape /// 상세 구조는 스펙 문서에 명시되지 않음 / Detailed structure not specified in spec use crate::error::HwpError; use serde::{Deserialize, Serialize}; /// 변경 추적 내용 및 모양 / Track change content and shape #[derive(Debug, Clone, Serialize, Deserialize)] pub struct TrackChangeContent { /// Raw data (가변) / Raw data (variable) #[serde(skip)] pub raw_data: Vec<u8>, } impl TrackChangeContent { /// TrackChangeContent를 바이트 배열에서 파싱합니다. / Parse TrackChangeContent from byte array. /// /// # Arguments /// * `data` - TrackChangeContent 데이터 (가변) / TrackChangeContent data (variable) /// /// # Returns /// 파싱된 TrackChangeContent 구조체 / Parsed TrackChangeContent structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { Ok(TrackChangeContent { raw_data: data.to_vec(), }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/distribute_doc_data.rs	crates/hwp-core/src/document/docinfo/distribute_doc_data.rs	/// DistributeDocData 구조체 / DistributeDocData structure /// /// 스펙 문서 매핑: 표 53 - 배포용 문서 데이터 / Spec mapping: Table 53 - Distribution document data use crate::error::HwpError; use serde::{Deserialize, Serialize}; /// 배포용 문서 데이터 (표 53) / Distribution document data (Table 53) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct DistributeDocData { /// 배포용 문서 데이터 (256바이트) / Distribution document data (256 bytes) pub data: Vec<u8>, } impl DistributeDocData { /// DistributeDocData를 바이트 배열에서 파싱합니다. / Parse DistributeDocData from byte array. /// /// # Arguments /// * `data` - DistributeDocData 데이터 (256바이트) / DistributeDocData data (256 bytes) /// /// # Returns /// 파싱된 DistributeDocData 구조체 / Parsed DistributeDocData structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 256 { return Err(HwpError::insufficient_data("DistributeDocData", 256, data.len())); } let doc_data = data[0..256].to_vec(); Ok(DistributeDocData { data: doc_data }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/bin_data.rs	crates/hwp-core/src/document/docinfo/bin_data.rs	/// BinData record structure /// /// This module handles parsing of HWPTAG_BIN_DATA records from DocInfo. /// /// 스펙 문서 매핑: 표 17 - 바이너리 데이터 / Spec mapping: Table 17 - Binary data /// Tag ID: HWPTAG_BIN_DATA use crate::error::HwpError; use crate::types::{decode_utf16le, UINT16, WORD}; use serde::{Deserialize, Serialize}; /// 바이너리 데이터 저장 타입 / Binary data storage type #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "UPPERCASE")] pub enum BinDataStorageType { /// LINK, 그림 외부 파일 참조 / Link, external file reference Link = 0x0000, /// EMBEDDING, 그림 파일 포함 / Embedding, embedded file Embedding = 0x0001, /// STORAGE, OLE 포함 / Storage, OLE embedded Storage = 0x0002, } impl BinDataStorageType { /// UINT16 값에서 BinDataStorageType 생성 / Create BinDataStorageType from UINT16 value fn from_u16(value: UINT16) -> Self { match value & 0x000F { 0x0000 => BinDataStorageType::Link, 0x0001 => BinDataStorageType::Embedding, 0x0002 => BinDataStorageType::Storage, _ => BinDataStorageType::Link, // Default fallback } } } /// 압축 타입 / Compression type #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum CompressionType { /// 스토리지의 디폴트 모드 따라감 / Follow storage default mode StorageDefault = 0x0000, /// 무조건 압축 / Always compress Compress = 0x0010, /// 무조건 압축하지 않음 / Never compress NoCompress = 0x0020, } impl CompressionType { /// UINT16 값에서 CompressionType 생성 / Create CompressionType from UINT16 value fn from_u16(value: UINT16) -> Self { match value & 0x0030 { 0x0000 => CompressionType::StorageDefault, 0x0010 => CompressionType::Compress, 0x0020 => CompressionType::NoCompress, _ => CompressionType::StorageDefault, // Default fallback } } } /// 접근 상태 / Access state #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum AccessState { /// 아직 access 된 적이 없는 상태 / Never accessed Never = 0x0000, /// access에 성공하여 파일을 찾은 상태 / Successfully accessed, file found Success = 0x0100, /// access가 실패한 에러 상태 / Access failed with error Failed = 0x0200, /// 링크 access가 실패했으나 무시된 상태 / Link access failed but ignored FailedIgnored = 0x0300, } impl AccessState { /// UINT16 값에서 AccessState 생성 / Create AccessState from UINT16 value fn from_u16(value: UINT16) -> Self { match value & 0x0300 { 0x0000 => AccessState::Never, 0x0100 => AccessState::Success, 0x0200 => AccessState::Failed, 0x0300 => AccessState::FailedIgnored, _ => AccessState::Never, // Default fallback } } } /// 바이너리 데이터 속성 / Binary data attributes #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct BinDataAttributes { /// 저장 타입 / Storage type pub storage_type: BinDataStorageType, /// 압축 타입 / Compression type pub compression: CompressionType, /// 접근 상태 / Access state pub access: AccessState, } impl BinDataAttributes { /// UINT16 값에서 BinDataAttributes 생성 / Create BinDataAttributes from UINT16 value fn from_u16(value: UINT16) -> Self { Self { storage_type: BinDataStorageType::from_u16(value), compression: CompressionType::from_u16(value), access: AccessState::from_u16(value), } } } /// LINK 타입 데이터 / Link type data #[derive(Debug, Clone, Serialize, Deserialize)] pub struct BinDataLink { /// 연결 파일의 절대 경로 / Absolute path of linked file pub absolute_path: String, /// 연결 파일의 상대 경로 / Relative path of linked file pub relative_path: String, } /// EMBEDDING 타입 데이터 / Embedding type data #[derive(Debug, Clone, Serialize, Deserialize)] pub struct BinDataEmbedding { /// BINDATASTORAGE에 저장된 바이너리 데이터의 아이디 / Binary data ID stored in BINDATASTORAGE pub binary_data_id: UINT16, /// 바이너리 데이터의 형식 이름 (extension, "." 제외) / Format name (extension without ".") /// - 그림의 경우: jpg, bmp, gif / For images: jpg, bmp, gif /// - OLE의 경우: ole / For OLE: ole pub extension: String, } /// STORAGE 타입 데이터 / Storage type data #[derive(Debug, Clone, Serialize, Deserialize)] pub struct BinDataStorage { /// BINDATASTORAGE에 저장된 바이너리 데이터의 아이디 / Binary data ID stored in BINDATASTORAGE pub binary_data_id: UINT16, } /// 바이너리 데이터 레코드 / Binary data record #[derive(Debug, Clone, Serialize, Deserialize)] #[serde(tag = "storage_type", rename_all = "UPPERCASE")] pub enum BinDataRecord { /// LINK 타입 / Link type Link { /// 속성 / Attributes attributes: BinDataAttributes, /// LINK 데이터 / Link data link: BinDataLink, }, /// EMBEDDING 타입 / Embedding type Embedding { /// 속성 / Attributes attributes: BinDataAttributes, /// EMBEDDING 데이터 / Embedding data embedding: BinDataEmbedding, }, /// STORAGE 타입 / Storage type Storage { /// 속성 / Attributes attributes: BinDataAttributes, /// STORAGE 데이터 / Storage data storage: BinDataStorage, }, } impl BinDataRecord { /// BinDataRecord를 바이트 배열에서 파싱합니다. / Parse BinDataRecord from byte array. /// /// # Arguments /// * `data` - BinDataRecord 데이터 / BinDataRecord data /// /// # Returns /// 파싱된 BinDataRecord 구조체 / Parsed BinDataRecord structure /// /// # 스펙 문서 매핑 / Spec mapping /// 표 17: 바이너리 데이터 / Table 17: Binary data pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 2 { return Err(HwpError::insufficient_data("BinDataRecord attributes", 2, data.len())); } let mut offset = 0; // 표 17: 속성 (UINT16, 2바이트) / Table 17: Attributes (UINT16, 2 bytes) let attr_value = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let attributes = BinDataAttributes::from_u16(attr_value); // Type에 따라 다른 필드 파싱 / Parse different fields based on type match attributes.storage_type { BinDataStorageType::Link => { // 표 17: Type이 "LINK"일 때 / Table 17: When Type is "LINK" // 연결 파일의 절대 경로 길이 (len1) / Absolute path length (len1) if data.len() < offset + 2 { return Err(HwpError::insufficient_data( "BinDataRecord LINK absolute path length", 2, data.len() - offset, )); } let len1 = WORD::from_le_bytes([data[offset], data[offset + 1]]) as usize; offset += 2; // 연결 파일의 절대 경로 / Absolute path if data.len() < offset + (len1 * 2) { return Err(HwpError::InsufficientData { field: format!("BinDataRecord LINK absolute path at offset {}", offset), expected: offset + (len1 * 2), actual: data.len(), }); } let absolute_path_bytes = &data[offset..offset + (len1 * 2)]; let absolute_path = decode_utf16le(absolute_path_bytes) .map_err(\|e\| HwpError::EncodingError { reason: format!("Failed to decode absolute path: {}", e), })?; offset += len1 * 2; // 연결 파일의 상대 경로 길이 (len2) / Relative path length (len2) if data.len() < offset + 2 { return Err(HwpError::insufficient_data( "BinDataRecord LINK relative path length", 2, data.len() - offset, )); } let len2 = WORD::from_le_bytes([data[offset], data[offset + 1]]) as usize; offset += 2; // 연결 파일의 상대 경로 / Relative path if data.len() < offset + (len2 * 2) { return Err(HwpError::InsufficientData { field: format!("BinDataRecord LINK relative path at offset {}", offset), expected: offset + (len2 * 2), actual: data.len(), }); } let relative_path_bytes = &data[offset..offset + (len2 * 2)]; let relative_path = decode_utf16le(relative_path_bytes) .map_err(\|e\| HwpError::EncodingError { reason: format!("Failed to decode relative path: {}", e), })?; Ok(BinDataRecord::Link { attributes, link: BinDataLink { absolute_path, relative_path, }, }) } BinDataStorageType::Embedding => { // 표 17: Type이 "EMBEDDING"일 때 / Table 17: When Type is "EMBEDDING" // BINDATASTORAGE에 저장된 바이너리 데이터의 아이디 / Binary data ID if data.len() < offset + 2 { return Err(HwpError::insufficient_data( "BinDataRecord EMBEDDING binary_data_id", 2, data.len() - offset, )); } let binary_data_id = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // 바이너리 데이터의 형식 이름의 길이 (len3) / Format name length (len3) if data.len() < offset + 2 { return Err(HwpError::insufficient_data( "BinDataRecord EMBEDDING extension length", 2, data.len() - offset, )); } let len3 = WORD::from_le_bytes([data[offset], data[offset + 1]]) as usize; offset += 2; // 바이너리 데이터의 형식 이름 (extension) / Format name (extension) if data.len() < offset + (len3 * 2) { return Err(HwpError::InsufficientData { field: format!("BinDataRecord EMBEDDING extension at offset {}", offset), expected: offset + (len3 * 2), actual: data.len(), }); } let extension_bytes = &data[offset..offset + (len3 * 2)]; let extension = decode_utf16le(extension_bytes) .map_err(\|e\| HwpError::EncodingError { reason: format!("Failed to decode extension: {}", e), })?; Ok(BinDataRecord::Embedding { attributes, embedding: BinDataEmbedding { binary_data_id, extension, }, }) } BinDataStorageType::Storage => { // 표 17: Type이 "STORAGE"일 때 / Table 17: When Type is "STORAGE" // BINDATASTORAGE에 저장된 바이너리 데이터의 아이디 / Binary data ID if data.len() < offset + 2 { return Err(HwpError::insufficient_data( "BinDataRecord STORAGE binary_data_id", 2, data.len() - offset, )); } let binary_data_id = UINT16::from_le_bytes([data[offset], data[offset + 1]]); Ok(BinDataRecord::Storage { attributes, storage: BinDataStorage { binary_data_id }, }) } } } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/compatible_document.rs	crates/hwp-core/src/document/docinfo/compatible_document.rs	/// CompatibleDocument 구조체 / CompatibleDocument structure /// /// 스펙 문서 매핑: 표 54 - 호환 문서 / Spec mapping: Table 54 - Compatible document use crate::error::HwpError; use crate::types::UINT32; use serde::{Deserialize, Serialize}; /// 호환 문서 (표 54) / Compatible document (Table 54) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct CompatibleDocument { /// 대상 프로그램 (표 55 참조) / Target program (see Table 55) pub target_program: TargetProgram, } /// 대상 프로그램 (표 55) / Target program (Table 55) #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum TargetProgram { /// 한글 문서(현재 버전) / HWP document (current version) HwpCurrent, /// 한글 2007 호환 문서 / HWP 2007 compatible document Hwp2007, /// MS 워드 호환 문서 / MS Word compatible document MsWord, } impl CompatibleDocument { /// CompatibleDocument를 바이트 배열에서 파싱합니다. / Parse CompatibleDocument from byte array. /// /// # Arguments /// * `data` - CompatibleDocument 데이터 (4바이트) / CompatibleDocument data (4 bytes) /// /// # Returns /// 파싱된 CompatibleDocument 구조체 / Parsed CompatibleDocument structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 4 { return Err(HwpError::insufficient_data("CompatibleDocument", 4, data.len())); } let target_program_value = UINT32::from_le_bytes([data[0], data[1], data[2], data[3]]); let target_program = match target_program_value { 0 => TargetProgram::HwpCurrent, 1 => TargetProgram::Hwp2007, 2 => TargetProgram::MsWord, _ => { return Err(HwpError::UnexpectedValue { field: "CompatibleDocument target_program".to_string(), expected: "0, 1, or 2".to_string(), found: target_program_value.to_string(), }); } }; Ok(CompatibleDocument { target_program }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/mod.rs	crates/hwp-core/src/document/docinfo/mod.rs	/// DocInfo parsing module /// /// This module handles parsing of HWP DocInfo stream. /// /// 스펙 문서 매핑: 표 2 - 문서 정보 (DocInfo 스트림) / Spec mapping: Table 2 - Document information (DocInfo stream) pub mod bin_data; pub mod border_fill; pub mod bullet; pub mod char_shape; pub mod compatible_document; pub mod constants; pub mod distribute_doc_data; pub mod doc_data; pub mod document_properties; pub mod face_name; pub mod forbidden_char; pub mod id_mappings; pub mod layout_compatibility; pub mod memo_shape; pub mod numbering; pub mod para_shape; pub mod style; pub mod tab_def; pub mod track_change; pub mod track_change_author; pub mod track_change_content; pub use crate::decompress::decompress_deflate; pub use crate::document::fileheader::FileHeader; pub use crate::error::HwpError; pub use crate::types::RecordHeader; pub use bin_data::BinDataRecord; pub use border_fill::{BorderFill, FillInfo}; pub use bullet::Bullet; pub use char_shape::CharShape; pub use compatible_document::CompatibleDocument; pub use constants::HwpTag; pub use distribute_doc_data::DistributeDocData; pub use doc_data::{DocData, ParameterSet}; pub use document_properties::DocumentProperties; pub use face_name::FaceName; pub use forbidden_char::ForbiddenChar; pub use id_mappings::IdMappings; pub use layout_compatibility::LayoutCompatibility; pub use memo_shape::MemoShape; pub use numbering::Numbering; pub use para_shape::{HeaderShapeType, ParaShape}; use serde::{Deserialize, Serialize}; pub use style::Style; pub use tab_def::TabDef; pub use track_change::TrackChange; pub use track_change_author::TrackChangeAuthor; pub use track_change_content::TrackChangeContent; /// Document information structure #[derive(Debug, Clone, Default, Serialize, Deserialize)] pub struct DocInfo { /// Document properties (parsed) pub document_properties: Option<DocumentProperties>, /// ID mappings (parsed) pub id_mappings: Option<IdMappings>, /// Binary data records (parsed) / 바이너리 데이터 레코드 (파싱됨) pub bin_data: Vec<BinDataRecord>, /// Face names (fonts) (parsed) / 글꼴 목록 (파싱됨) pub face_names: Vec<FaceName>, /// Border/fill information (parsed) / 테두리/배경 정보 (파싱됨) pub border_fill: Vec<BorderFill>, /// Character shapes (parsed) / 글자 모양 (파싱됨) pub char_shapes: Vec<CharShape>, /// Tab definitions (parsed) / 탭 정의 (파싱됨) pub tab_defs: Vec<TabDef>, /// Numbering information (parsed) / 문단 번호 정보 (파싱됨) pub numbering: Vec<Numbering>, /// Bullet information (parsed) / 글머리표 정보 (파싱됨) pub bullets: Vec<Bullet>, /// Paragraph shapes (parsed) / 문단 모양 (파싱됨) pub para_shapes: Vec<ParaShape>, /// Styles (parsed) / 스타일 (파싱됨) pub styles: Vec<Style>, /// Document arbitrary data (parsed) / 문서 임의의 데이터 (파싱됨) pub doc_data: Vec<DocData>, /// Distribution document data (parsed) / 배포용 문서 데이터 (파싱됨) pub distribute_doc_data: Option<DistributeDocData>, /// Compatible document (parsed) / 호환 문서 (파싱됨) pub compatible_document: Option<CompatibleDocument>, /// Layout compatibility (parsed) / 레이아웃 호환성 (파싱됨) pub layout_compatibility: Option<LayoutCompatibility>, /// Track change information (parsed) / 변경 추적 정보 (파싱됨) pub track_change: Option<TrackChange>, /// Memo shapes (parsed) / 메모 모양 (파싱됨) pub memo_shapes: Vec<MemoShape>, /// Forbidden characters (parsed) / 금칙처리 문자 (파싱됨) pub forbidden_chars: Vec<ForbiddenChar>, /// Track change contents (parsed) / 변경 추적 내용 및 모양 (파싱됨) pub track_change_contents: Vec<TrackChangeContent>, /// Track change authors (parsed) / 변경 추적 작성자 (파싱됨) pub track_change_authors: Vec<TrackChangeAuthor>, } impl DocInfo { /// DocInfo 스트림을 파싱합니다. / Parse DocInfo stream. /// /// # Arguments /// * `stream_data` - DocInfo 스트림의 원시 바이트 데이터 / Raw byte data of DocInfo stream /// * `file_header` - FileHeader (압축 여부 확인용) / FileHeader (to check compression) /// /// # Returns /// 파싱된 DocInfo 구조체 / Parsed DocInfo structure pub fn parse(stream_data: &[u8], file_header: &FileHeader) -> Result<Self, HwpError> { // 압축 해제 (필요한 경우) / Decompress if needed // HWP DocInfo uses raw deflate format (windowBits: -15), not zlib let decompressed_data = if file_header.is_compressed() { decompress_deflate(stream_data)? } else { stream_data.to_vec() }; let mut doc_info = DocInfo::default(); let mut offset = 0; // 레코드 단위로 파싱 / Parse record by record while offset < decompressed_data.len() { // 레코드 헤더 파싱 / Parse record header let remaining_data = &decompressed_data[offset..]; let (header, header_size) = RecordHeader::parse(remaining_data).map_err(\|e\| HwpError::from(e))?; offset += header_size; // 데이터 영역 읽기 / Read data area let data_size = header.size as usize; if offset + data_size > decompressed_data.len() { return Err(HwpError::InsufficientData { field: format!("DocInfo record at offset {}", offset), expected: offset + data_size, actual: decompressed_data.len(), }); } let record_data = &decompressed_data[offset..offset + data_size]; offset += data_size; // 태그별로 분류하여 저장 / Classify and store by tag match header.tag_id { HwpTag::DOCUMENT_PROPERTIES => { if header.level == 0 { // DocumentProperties는 완전히 파싱 / Fully parse DocumentProperties let props = DocumentProperties::parse(record_data) .map_err(\|e\| HwpError::from(e))?; doc_info.document_properties = Some(props); } } HwpTag::ID_MAPPINGS => { if header.level == 0 { // IdMappings는 완전히 파싱 / Fully parse IdMappings let id_mappings = IdMappings::parse(record_data, file_header.version) .map_err(\|e\| HwpError::from(e))?; doc_info.id_mappings = Some(id_mappings); } } HwpTag::BIN_DATA => { if header.level == 1 { // BinDataRecord는 완전히 파싱 / Fully parse BinDataRecord let bin_data_record = BinDataRecord::parse(record_data).map_err(\|e\| HwpError::from(e))?; doc_info.bin_data.push(bin_data_record); } } HwpTag::FACE_NAME => { if header.level == 1 { // FaceName은 완전히 파싱 / Fully parse FaceName let face_name = FaceName::parse(record_data).map_err(\|e\| HwpError::from(e))?; doc_info.face_names.push(face_name); } } HwpTag::BORDER_FILL => { if header.level == 1 { // BorderFill은 완전히 파싱 / Fully parse BorderFill let border_fill = BorderFill::parse(record_data).map_err(\|e\| HwpError::from(e))?; doc_info.border_fill.push(border_fill); } } HwpTag::CHAR_SHAPE => { if header.level == 1 { // CharShape는 완전히 파싱 / Fully parse CharShape let char_shape = CharShape::parse(record_data, file_header.version) .map_err(\|e\| HwpError::from(e))?; doc_info.char_shapes.push(char_shape); } } HwpTag::TAB_DEF => { if header.level == 1 { // TabDef는 완전히 파싱 / Fully parse TabDef let tab_def = TabDef::parse(record_data).map_err(\|e\| HwpError::from(e))?; doc_info.tab_defs.push(tab_def); } } HwpTag::NUMBERING => { if header.level == 1 { // Numbering은 완전히 파싱 / Fully parse Numbering let numbering = Numbering::parse(record_data, file_header.version) .map_err(\|e\| HwpError::from(e))?; doc_info.numbering.push(numbering); } } HwpTag::BULLET => { if header.level == 1 { // Bullet은 완전히 파싱 / Fully parse Bullet let bullet = Bullet::parse(record_data).map_err(\|e\| HwpError::from(e))?; doc_info.bullets.push(bullet); } } HwpTag::PARA_SHAPE => { if header.level == 1 { // ParaShape은 완전히 파싱 / Fully parse ParaShape let para_shape = ParaShape::parse(record_data, file_header.version) .map_err(\|e\| HwpError::from(e))?; doc_info.para_shapes.push(para_shape); } } HwpTag::STYLE => { if header.level == 1 { let style = Style::parse(record_data).map_err(\|e\| HwpError::from(e))?; doc_info.styles.push(style); } } HwpTag::DOC_DATA => { if header.level == 0 { // 문서 임의의 데이터 파싱 / Parse document arbitrary data let doc_data = DocData::parse(record_data).map_err(\|e\| HwpError::from(e))?; doc_info.doc_data.push(doc_data); } } HwpTag::DISTRIBUTE_DOC_DATA => { if header.level == 0 { // 배포용 문서 데이터 파싱 / Parse distribution document data let distribute_doc_data = DistributeDocData::parse(record_data).map_err(\|e\| HwpError::from(e))?; doc_info.distribute_doc_data = Some(distribute_doc_data); } } HwpTag::COMPATIBLE_DOCUMENT => { if header.level == 0 { // 호환 문서 파싱 / Parse compatible document let compatible_document = CompatibleDocument::parse(record_data) .map_err(\|e\| HwpError::from(e))?; doc_info.compatible_document = Some(compatible_document); } } HwpTag::LAYOUT_COMPATIBILITY => { if header.level == 1 { // 레이아웃 호환성 파싱 / Parse layout compatibility let layout_compatibility = LayoutCompatibility::parse(record_data) .map_err(\|e\| HwpError::from(e))?; doc_info.layout_compatibility = Some(layout_compatibility); } } HwpTag::TRACKCHANGE => { if header.level == 1 { // 변경 추적 정보 파싱 / Parse track change information let track_change = TrackChange::parse(record_data).map_err(\|e\| HwpError::from(e))?; doc_info.track_change = Some(track_change); } } HwpTag::MEMO_SHAPE => { if header.level == 1 { // 메모 모양 파싱 / Parse memo shape let memo_shape = MemoShape::parse(record_data).map_err(\|e\| HwpError::from(e))?; doc_info.memo_shapes.push(memo_shape); } } HwpTag::FORBIDDEN_CHAR => { if header.level == 0 { // 금칙처리 문자 파싱 / Parse forbidden character let forbidden_char = ForbiddenChar::parse(record_data).map_err(\|e\| HwpError::from(e))?; doc_info.forbidden_chars.push(forbidden_char); } } HwpTag::TRACK_CHANGE => { if header.level == 1 { // 변경 추적 내용 및 모양 파싱 / Parse track change content and shape let track_change_content = TrackChangeContent::parse(record_data) .map_err(\|e\| HwpError::from(e))?; doc_info.track_change_contents.push(track_change_content); } } HwpTag::TRACK_CHANGE_AUTHOR => { if header.level == 1 { // 변경 추적 작성자 파싱 / Parse track change author let track_change_author = TrackChangeAuthor::parse(record_data).map_err(\|e\| HwpError::from(e))?; doc_info.track_change_authors.push(track_change_author); } } // 기타 태그는 무시 (나중에 구현 가능) / Other tags are ignored (can be implemented later) _ => { // 알 수 없는 태그는 무시하고 계속 진행 / Unknown tags are ignored and continue } } } Ok(doc_info) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/style.rs	crates/hwp-core/src/document/docinfo/style.rs	/// Style 구조체 / Style structure /// /// 스펙 문서 매핑: 표 47 - 스타일 / Spec mapping: Table 47 - Style /// Tag ID: HWPTAG_STYLE /// 전체 길이: 가변 (12 + 2×len1 + 2×len2 바이트) / Total length: variable (12 + 2×len1 + 2×len2 bytes) use crate::error::HwpError; use crate::types::{decode_utf16le, BYTE, INT16, UINT16, WORD}; use serde::{Deserialize, Serialize}; /// 스타일 종류 / Style type #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum StyleType { /// 문단 스타일 / Paragraph style Paragraph = 0, /// 글자 스타일 / Character style Character = 1, } impl StyleType { fn from_bits(bits: u8) -> Self { match bits & 0x07 { 1 => StyleType::Character, _ => StyleType::Paragraph, } } } /// Style 구조체 / Style structure #[derive(Debug, Clone, Serialize, Deserialize)] pub struct Style { /// 로컬/한글 스타일 이름 / Local/Korean style name pub local_name: String, /// 영문 스타일 이름 / English style name pub english_name: String, /// 속성 (표 48 참조, bit 0-2: 스타일 종류) / Attributes (See Table 48, bit 0-2: style type) pub style_type: StyleType, /// 다음 스타일 ID 참조 값 / Next style ID reference value pub next_style_id: BYTE, /// 언어 ID (표 48 참조) / Language ID (See Table 48) pub lang_id: INT16, /// 문단 모양 ID 참조 값 (스타일 종류가 문단인 경우 필수) / Paragraph shape ID reference (required if style type is paragraph) pub para_shape_id: Option<UINT16>, /// 글자 모양 ID (스타일 종류가 글자인 경우 필수) / Character shape ID (required if style type is character) pub char_shape_id: Option<UINT16>, } impl Style { /// Style을 바이트 배열에서 파싱합니다. / Parse Style from byte array. /// /// # Arguments /// * `data` - Style 레코드 데이터 / Style record data /// /// # Returns /// 파싱된 Style 구조체 / Parsed Style structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // 최소 12바이트 필요 (고정 필드들) / Need at least 12 bytes for fixed fields if data.len() < 12 { return Err(HwpError::insufficient_data("Style", 12, data.len())); } let mut offset = 0; // WORD 길이(len1) / WORD length (len1) let len1 = WORD::from_le_bytes([data[offset], data[offset + 1]]) as usize; offset += 2; // WCHAR array[len1] 로컬/한글 스타일 이름 / WCHAR array[len1] local/Korean style name if offset + (len1 * 2) > data.len() { return Err(HwpError::InsufficientData { field: format!("Style local name at offset {}", offset), expected: offset + (len1 * 2), actual: data.len(), }); } let local_name_bytes = &data[offset..offset + (len1 * 2)]; let local_name = decode_utf16le(local_name_bytes) .map_err(\|e\| HwpError::EncodingError { reason: format!("Failed to decode local name: {}", e), })?; offset += len1 * 2; // WORD 길이(len2) / WORD length (len2) if offset + 2 > data.len() { return Err(HwpError::insufficient_data( "Style English name length", 2, data.len() - offset, )); } let len2 = WORD::from_le_bytes([data[offset], data[offset + 1]]) as usize; offset += 2; // WCHAR array[len2] 영문 스타일 이름 / WCHAR array[len2] English style name if offset + (len2 * 2) > data.len() { return Err(HwpError::InsufficientData { field: format!("Style English name at offset {}", offset), expected: offset + (len2 * 2), actual: data.len(), }); } let english_name_bytes = &data[offset..offset + (len2 * 2)]; let english_name = decode_utf16le(english_name_bytes) .map_err(\|e\| HwpError::EncodingError { reason: format!("Failed to decode English name: {}", e), })?; offset += len2 * 2; // BYTE 속성 (표 48 참조, bit 0-2: 스타일 종류) / BYTE attributes (See Table 48, bit 0-2: style type) if offset + 1 > data.len() { return Err(HwpError::insufficient_data( "Style attributes", 1, data.len() - offset, )); } let attributes = data[offset]; offset += 1; let style_type = StyleType::from_bits(attributes); // BYTE 다음 스타일 ID 참조 값 / BYTE next style ID reference value if offset + 1 > data.len() { return Err(HwpError::insufficient_data( "Style next style ID", 1, data.len() - offset, )); } let next_style_id = data[offset]; offset += 1; // INT16 언어 ID (표 48 참조) / INT16 language ID (See Table 48) if offset + 2 > data.len() { return Err(HwpError::insufficient_data( "Style language ID", 2, data.len() - offset, )); } let lang_id = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT16 문단 모양 ID 참조 값 (스타일 종류가 문단인 경우 필수) / UINT16 paragraph shape ID reference (required if style type is paragraph) if offset + 2 > data.len() { return Err(HwpError::insufficient_data( "Style paragraph shape ID", 2, data.len() - offset, )); } let para_shape_id_value = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let para_shape_id = if style_type == StyleType::Paragraph { Some(para_shape_id_value) } else { None }; // UINT16 글자 모양 ID (스타일 종류가 글자인 경우 필수) / UINT16 character shape ID (required if style type is character) if offset + 2 > data.len() { return Err(HwpError::insufficient_data( "Style character shape ID", 2, data.len() - offset, )); } let char_shape_id_value = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let char_shape_id = if style_type == StyleType::Character { Some(char_shape_id_value) } else { None }; Ok(Style { local_name, english_name, style_type, next_style_id, lang_id, para_shape_id, char_shape_id, }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/numbering.rs	crates/hwp-core/src/document/docinfo/numbering.rs	/// Numbering 구조체 / Numbering structure /// /// 스펙 문서 매핑: 표 38 - 문단 번호 / Spec mapping: Table 38 - Paragraph numbering /// Tag ID: HWPTAG_NUMBERING /// 전체 길이: 가변 / Total length: variable use crate::error::HwpError; use crate::types::{decode_utf16le, HWPUNIT16, UINT16, UINT32, WORD}; use serde::{Deserialize, Serialize}; /// 문단 머리 정보 속성 / Paragraph header information attributes #[derive(Debug, Clone, Serialize, Deserialize)] pub struct NumberingHeaderAttributes { /// 문단의 정렬 종류 / Paragraph alignment type pub align_type: ParagraphAlignType, /// 인스턴스 유사 여부 (bit 2) / Instance-like flag (bit 2) pub instance_like: bool, /// 자동 내어 쓰기 여부 / Auto outdent flag pub auto_outdent: bool, /// 수준별 본문과의 거리 종류 / Distance type from body text by level pub distance_type: DistanceType, } /// 문단 정렬 종류 / Paragraph alignment type #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum ParagraphAlignType { /// 왼쪽 / Left Left = 0, /// 가운데 / Center Center = 1, /// 오른쪽 / Right Right = 2, } impl ParagraphAlignType { fn from_bits(bits: u32) -> Self { match bits & 0x00000003 { 1 => ParagraphAlignType::Center, 2 => ParagraphAlignType::Right, _ => ParagraphAlignType::Left, } } } /// 수준별 본문과의 거리 종류 / Distance type from body text by level #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum DistanceType { /// 글자 크기에 대한 상대 비율 / Relative ratio to font size Ratio = 0, /// 값 / Value Value = 1, } impl DistanceType { fn from_bit(bit: bool) -> Self { if bit { DistanceType::Value } else { DistanceType::Ratio } } } /// 문단 머리 정보 (수준별) / Paragraph header information (per level) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct NumberingLevelInfo { /// 속성 (표 40) / Attributes (Table 40) pub attributes: NumberingHeaderAttributes, /// 너비 보정값 / Width correction value pub width: HWPUNIT16, /// 본문과의 거리 / Distance from body text pub distance: HWPUNIT16, /// 글자 모양 아이디 참조 / Character shape ID reference pub char_shape_id: UINT32, /// 번호 형식 길이 / Number format length pub format_length: WORD, /// 번호 형식 문자열 / Number format string pub format_string: String, /// 시작 번호 / Start number pub start_number: UINT16, /// 수준별 시작번호 (5.0.2.5 이상, 옵션) / Level-specific start number (5.0.2.5+, optional) pub level_start_number: Option<UINT32>, } /// Numbering 구조체 / Numbering structure #[derive(Debug, Clone, Serialize, Deserialize)] pub struct Numbering { /// 수준별 문단 머리 정보 (7개 수준, 1~7) / Level-specific paragraph header information (7 levels, 1~7) pub levels: Vec<NumberingLevelInfo>, /// 확장 번호 형식 (3개 수준, 8~10, 옵션) / Extended number format (3 levels, 8~10, optional) pub extended_levels: Vec<ExtendedNumberingLevel>, } /// 확장 번호 형식 (수준 8~10) / Extended number format (levels 8~10) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ExtendedNumberingLevel { /// 번호 형식 길이 / Number format length pub format_length: WORD, /// 번호 형식 문자열 / Number format string pub format_string: String, } impl Numbering { /// Numbering을 바이트 배열에서 파싱합니다. / Parse Numbering from byte array. /// /// # Arguments /// * `data` - Numbering 레코드 데이터 / Numbering record data /// * `version` - HWP 파일 버전 (5.0.2.5 이상에서 수준별 시작번호 지원) / HWP file version (level-specific start numbers supported in 5.0.2.5+) /// /// # Returns /// 파싱된 Numbering 구조체 / Parsed Numbering structure pub fn parse(data: &[u8], version: u32) -> Result<Self, HwpError> { let mut offset = 0; let mut levels = Vec::new(); // 7개 수준 파싱 (1~7) / Parse 7 levels (1~7) for _ in 0..7 { // 데이터가 부족하면 기본값으로 채우고 종료 / Fill with defaults and exit if insufficient data if offset + 12 > data.len() { // 최소 12바이트 (속성 4 + 너비 2 + 거리 2 + 글자모양ID 4) 필요 / Need at least 12 bytes break; } // UINT 속성 (표 40) / UINT attributes (Table 40) let attr_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let attributes = NumberingHeaderAttributes { align_type: ParagraphAlignType::from_bits(attr_value), instance_like: (attr_value & 0x00000004) != 0, auto_outdent: (attr_value & 0x00000008) != 0, distance_type: DistanceType::from_bit((attr_value & 0x00000010) != 0), }; // HWPUNIT16 너비 보정값 / HWPUNIT16 width correction value let width = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // HWPUNIT16 본문과의 거리 / HWPUNIT16 distance from body text let distance = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT 글자 모양 아이디 참조 / UINT character shape ID reference let char_shape_id = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // WORD 번호 형식 길이 / WORD number format length let (format_length, format_string) = if offset + 2 <= data.len() { let len = WORD::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // WCHAR array[format_length] 번호 형식 문자열 / WCHAR array[format_length] number format string let format_bytes = len as usize * 2; if offset + format_bytes <= data.len() { let str = decode_utf16le(&data[offset..offset + format_bytes]) .map_err(\|e\| HwpError::EncodingError { reason: format!("Failed to decode numbering format: {}", e), })?; offset += format_bytes; (len, str) } else { // 데이터가 부족하면 빈 문자열 / Empty string if insufficient data (0, String::new()) } } else { // 데이터가 부족하면 기본값 사용 / Use default if insufficient data (0, String::new()) }; // UINT16 시작 번호 / UINT16 start number let start_number = if offset + 2 <= data.len() { let value = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; value } else { 0 }; // UINT 수준별 시작번호 (5.0.2.5 이상, 옵션) / UINT level-specific start number (5.0.2.5+, optional) let level_start_number = if version >= 0x00020500 && offset + 4 <= data.len() { let value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; Some(value) } else { None }; levels.push(NumberingLevelInfo { attributes, width, distance, char_shape_id, format_length, format_string, start_number, level_start_number, }); } // 확장 번호 형식 파싱 (3개 수준, 8~10) / Parse extended number format (3 levels, 8~10) let mut extended_levels = Vec::new(); for _ in 0..3 { if offset + 2 > data.len() { // 확장 레벨이 없을 수 있음 / Extended levels may not exist break; } // WORD 확장 번호 형식 길이 / WORD extended number format length let format_length = WORD::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // WCHAR array[format_length] 확장 번호 형식 문자열 / WCHAR array[format_length] extended number format string let format_bytes = format_length as usize * 2; if offset + format_bytes > data.len() { // 확장 레벨 데이터가 불완전할 수 있음 / Extended level data may be incomplete break; } let format_string = decode_utf16le(&data[offset..offset + format_bytes]) .map_err(\|e\| HwpError::EncodingError { reason: format!("Failed to decode extended numbering format: {}", e), })?; offset += format_bytes; extended_levels.push(ExtendedNumberingLevel { format_length, format_string, }); } Ok(Numbering { levels, extended_levels, }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/constants.rs	crates/hwp-core/src/document/docinfo/constants.rs	/// DocInfo 태그 상수 정의 / DocInfo tag constants definition /// /// 스펙 문서 매핑: 표 13 - 문서 정보의 데이터 레코드 / Spec mapping: Table 13 - Document information data records use crate::document::constants::HWPTAG_BEGIN; /// DocInfo 태그 상수 / DocInfo tag constants pub struct HwpTag; impl HwpTag { /// 문서 속성 / Document properties pub const DOCUMENT_PROPERTIES: u16 = HWPTAG_BEGIN; /// 아이디 매핑 헤더 / ID mappings header pub const ID_MAPPINGS: u16 = HWPTAG_BEGIN + 1; /// 바이너리 데이터 / Binary data pub const BIN_DATA: u16 = HWPTAG_BEGIN + 2; /// 글꼴 (Typeface Name) / Face name (Typeface Name) pub const FACE_NAME: u16 = HWPTAG_BEGIN + 3; /// 테두리/배경 / Border/fill pub const BORDER_FILL: u16 = HWPTAG_BEGIN + 4; /// 글자 모양 / Character shape pub const CHAR_SHAPE: u16 = HWPTAG_BEGIN + 5; /// 탭 정의 / Tab definition pub const TAB_DEF: u16 = HWPTAG_BEGIN + 6; /// 번호 정의 / Numbering definition pub const NUMBERING: u16 = HWPTAG_BEGIN + 7; /// 불릿 정의 / Bullet definition pub const BULLET: u16 = HWPTAG_BEGIN + 8; /// 문단 모양 / Paragraph shape pub const PARA_SHAPE: u16 = HWPTAG_BEGIN + 9; /// 스타일 / Style pub const STYLE: u16 = HWPTAG_BEGIN + 10; /// 문서의 임의의 데이터 / Document arbitrary data pub const DOC_DATA: u16 = HWPTAG_BEGIN + 11; /// 배포용 문서 데이터 / Distribution document data pub const DISTRIBUTE_DOC_DATA: u16 = HWPTAG_BEGIN + 12; /// 예약 / Reserved pub const RESERVED: u16 = HWPTAG_BEGIN + 13; /// 호환 문서 / Compatible document pub const COMPATIBLE_DOCUMENT: u16 = HWPTAG_BEGIN + 14; /// 레이아웃 호환성 / Layout compatibility pub const LAYOUT_COMPATIBILITY: u16 = HWPTAG_BEGIN + 15; /// 변경 추적 정보 / Track change information pub const TRACKCHANGE: u16 = HWPTAG_BEGIN + 16; /// 메모 모양 / Memo shape pub const MEMO_SHAPE: u16 = HWPTAG_BEGIN + 76; /// 금칙처리 문자 / Forbidden character pub const FORBIDDEN_CHAR: u16 = HWPTAG_BEGIN + 78; /// 변경 추적 내용 및 모양 / Track change content and shape pub const TRACK_CHANGE: u16 = HWPTAG_BEGIN + 80; /// 변경 추적 작성자 / Track change author pub const TRACK_CHANGE_AUTHOR: u16 = HWPTAG_BEGIN + 81; }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/doc_data.rs	crates/hwp-core/src/document/docinfo/doc_data.rs	/// DocData 구조체 / DocData structure /// /// 스펙 문서 매핑: 표 49 - 문서 임의의 데이터 / Spec mapping: Table 49 - Document arbitrary data use crate::error::HwpError; use crate::types::{decode_utf16le, INT16, INT32, INT8, UINT16, UINT32, UINT8, WORD}; use serde::{Deserialize, Serialize}; /// 문서 임의의 데이터 (표 49) / Document arbitrary data (Table 49) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct DocData { /// 파라미터 셋 (표 50 참조) / Parameter set (see Table 50) pub parameter_set: ParameterSet, } /// 파라미터 셋 (표 50) / Parameter set (Table 50) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ParameterSet { /// 파라미터 셋 ID / Parameter set ID pub set_id: WORD, /// 파라미터 셋에 존재하는 아이템 개수 / Number of items in parameter set pub item_count: INT16, /// 파라미터 아이템 리스트 / Parameter item list pub items: Vec<ParameterItem>, } /// 파라미터 아이템 (표 51) / Parameter item (Table 51) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ParameterItem { /// 파라미터 아이템 ID / Parameter item ID pub id: WORD, /// 파라미터 아이템 종류 (표 52 참조) / Parameter item type (see Table 52) pub item_type: ParameterItemType, /// 파라미터 아이템 데이터 / Parameter item data pub data: ParameterItemData, } /// 파라미터 아이템 종류 (표 52) / Parameter item type (Table 52) #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum ParameterItemType { /// NULL / NULL Null, /// 문자열 / String Bstr, /// INT8 / INT8 I1, /// INT16 / INT16 I2, /// INT32 / INT32 I4, /// INT / INT I, /// UINT8 / UINT8 Ui1, /// UINT16 / UINT16 Ui2, /// UINT32 / UINT32 Ui4, /// UINT / UINT Ui, /// 파라미터 셋 / Parameter set Set, /// 파라미터 셋 배열 / Parameter set array Array, /// 바이너리 데이터 ID / Binary data ID Bindata, } /// 파라미터 아이템 데이터 / Parameter item data #[derive(Debug, Clone, Serialize, Deserialize)] #[serde(tag = "type", rename_all = "snake_case")] pub enum ParameterItemData { /// NULL / NULL Null, /// 문자열 / String Bstr(String), /// INT8 / INT8 I1(INT8), /// INT16 / INT16 I2(INT16), /// INT32 / INT32 I4(INT32), /// INT / INT I(INT8), /// UINT8 / UINT8 Ui1(UINT8), /// UINT16 / UINT16 Ui2(UINT16), /// UINT32 / UINT32 Ui4(UINT32), /// UINT / UINT Ui(UINT8), /// 파라미터 셋 / Parameter set Set(ParameterSet), /// 파라미터 셋 배열 / Parameter set array Array(Vec<ParameterSet>), /// 바이너리 데이터 ID / Binary data ID Bindata(UINT16), } impl DocData { /// DocData를 바이트 배열에서 파싱합니다. / Parse DocData from byte array. /// /// # Arguments /// * `data` - DocData 데이터 / DocData data /// /// # Returns /// 파싱된 DocData 구조체 / Parsed DocData structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.is_empty() { return Err(HwpError::InsufficientData { field: "DocData data".to_string(), expected: 1, actual: 0, }); } // 파라미터 셋 파싱 (표 50) / Parse parameter set (Table 50) let parameter_set = ParameterSet::parse(data)?; Ok(DocData { parameter_set }) } } impl ParameterSet { /// ParameterSet을 바이트 배열에서 파싱합니다. / Parse ParameterSet from byte array. /// /// # Arguments /// * `data` - ParameterSet 데이터 / ParameterSet data /// /// # Returns /// 파싱된 ParameterSet 구조체 / Parsed ParameterSet structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 4 { return Err(HwpError::insufficient_data("ParameterSet", 4, data.len())); } let mut offset = 0; // WORD 파라미터 셋 ID / WORD parameter set ID let set_id = WORD::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // INT16 파라미터 셋에 존재하는 아이템 개수 / INT16 number of items in parameter set let item_count = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // 파라미터 아이템 파싱 / Parse parameter items let mut items = Vec::new(); let mut current_offset = offset; for _ in 0..item_count { if current_offset >= data.len() { break; // 데이터가 부족할 수 있음 / Data may be insufficient } match ParameterItem::parse(&data[current_offset..]) { Ok((item, item_size)) => { items.push(item); current_offset += item_size; } Err(e) => { // 파싱 실패 시 경고하고 계속 진행 / Warn and continue on parse failure // 알 수 없는 타입의 경우 ParameterItem::parse에서 이미 처리하므로 여기 도달하지 않아야 함 // Continue on parse error with warning // Unknown types should be handled in ParameterItem::parse, so this shouldn't be reached #[cfg(debug_assertions)] eprintln!("Failed to parse parameter item: {}", e); // 에러가 발생한 경우 최소한 id와 item_type(4바이트)는 건너뛰고 계속 진행 // On error, skip at least id and item_type (4 bytes) and continue if current_offset + 4 <= data.len() { current_offset += 4; } else { break; } } } } Ok(ParameterSet { set_id, item_count, items, }) } } impl ParameterItem { /// ParameterItem을 바이트 배열에서 파싱합니다. / Parse ParameterItem from byte array. /// /// # Arguments /// * `data` - ParameterItem 데이터 / ParameterItem data /// /// # Returns /// 파싱된 ParameterItem과 사용된 바이트 수 / Parsed ParameterItem and bytes consumed pub fn parse(data: &[u8]) -> Result<(Self, usize), HwpError> { if data.len() < 4 { return Err(HwpError::insufficient_data("ParameterItem", 4, data.len())); } let mut offset = 0; // WORD 파라미터 아이템 ID / WORD parameter item ID let id = WORD::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // WORD 파라미터 아이템 종류 (표 52 참조) / WORD parameter item type (see Table 52) let item_type_value = WORD::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let item_type = match item_type_value { 0 => ParameterItemType::Null, 1 => ParameterItemType::Bstr, 2 => ParameterItemType::I1, 3 => ParameterItemType::I2, 4 => ParameterItemType::I4, 5 => ParameterItemType::I, 6 => ParameterItemType::Ui1, 7 => ParameterItemType::Ui2, 8 => ParameterItemType::Ui4, 9 => ParameterItemType::Ui, 0x8000 => ParameterItemType::Set, 0x8001 => ParameterItemType::Array, 0x8002 => ParameterItemType::Bindata, _ => { // 스펙 문서(표 52)에 명시되지 않은 알 수 없는 타입 // Unknown type not specified in spec (Table 52) // // 이유: 스펙 문서 표 52에는 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0x8000, 0x8001, 0x8002만 정의되어 있음 // Reason: Spec document Table 52 only defines 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0x8000, 0x8001, 0x8002 // // 실제 파일에서 발견된 타입(예: 519 = 0x0207)은 스펙 문서에 없으므로 // 데이터 크기를 알 수 없어 파싱할 수 없음 // Types found in actual files (e.g., 519 = 0x0207) are not in spec, // so we cannot determine data size and cannot parse // // 별도 처리: 알 수 없는 타입의 경우 id와 item_type만 저장하고 데이터는 건너뜀 // Special handling: For unknown types, only save id and item_type, skip data #[cfg(debug_assertions)] eprintln!( "Warning: Unknown parameter item type: {} (0x{:04x}) - not in spec Table 52, skipping data", item_type_value, item_type_value ); // 알 수 없는 타입의 경우 데이터 크기를 알 수 없으므로, id와 item_type만 반환 // For unknown types, we can't determine data size, so return only id and item_type return Ok(( ParameterItem { id, item_type: ParameterItemType::Null, // 알 수 없는 타입이므로 Null로 표시 / Mark as Null for unknown type data: ParameterItemData::Null, }, 4, // id(2) + item_type(2)만 사용 / Only id(2) + item_type(2) consumed )); } }; // 파라미터 아이템 데이터 파싱 / Parse parameter item data let (data_value, data_size) = parse_parameter_item_data(&data[offset..], item_type) .map_err(\|e\| HwpError::from(e))?; offset += data_size; Ok(( ParameterItem { id, item_type, data: data_value, }, offset, )) } } /// 파라미터 아이템 데이터 파싱 / Parse parameter item data fn parse_parameter_item_data( data: &[u8], item_type: ParameterItemType, ) -> Result<(ParameterItemData, usize), HwpError> { match item_type { ParameterItemType::Null => { // PIT_NULL: UINT \| NULL // 스펙 문서: "UINT \| NULL" - NULL이므로 데이터 없음 // Spec: "UINT \| NULL" - no data for NULL Ok((ParameterItemData::Null, 0)) } ParameterItemType::Bstr => { // PIT_BSTR: WORD 문자열 길이(slen) + WCHAR array[len] // 스펙 문서: "WORD \| 문자열 길이(slen)" + "WCHAR array[len]" // Spec: "WORD \| string length(slen)" + "WCHAR array[len]" if data.len() < 2 { return Err(HwpError::insufficient_data("BSTR length", 2, data.len())); } let string_len = WORD::from_le_bytes([data[0], data[1]]) as usize; let total_size = 2 + (string_len * 2); // WORD(2) + WCHAR array if data.len() < total_size { return Err(HwpError::InsufficientData { field: "BSTR data".to_string(), expected: total_size, actual: data.len(), }); } let string_bytes = &data[2..total_size]; let string = decode_utf16le(string_bytes) .map_err(\|e\| HwpError::EncodingError { reason: format!("Failed to decode BSTR: {}", e), })?; Ok((ParameterItemData::Bstr(string), total_size)) } ParameterItemType::I1 => { // PIT_I1: INT8 / PIT_I1: INT8 if data.len() < 1 { return Err(HwpError::insufficient_data("I1", 1, data.len())); } Ok((ParameterItemData::I1(INT8::from_le_bytes([data[0]])), 1)) } ParameterItemType::I2 => { // PIT_I2: INT16 / PIT_I2: INT16 if data.len() < 2 { return Err(HwpError::insufficient_data("I2", 2, data.len())); } Ok(( ParameterItemData::I2(INT16::from_le_bytes([data[0], data[1]])), 2, )) } ParameterItemType::I4 => { // PIT_I4: INT32 / PIT_I4: INT32 if data.len() < 4 { return Err(HwpError::insufficient_data("I4", 4, data.len())); } Ok(( ParameterItemData::I4(INT32::from_le_bytes([data[0], data[1], data[2], data[3]])), 4, )) } ParameterItemType::I => { // PIT_I: INT8 / PIT_I: INT8 if data.len() < 1 { return Err(HwpError::insufficient_data("I", 1, data.len())); } Ok((ParameterItemData::I(INT8::from_le_bytes([data[0]])), 1)) } ParameterItemType::Ui1 => { // PIT_UI1: UINT8 / PIT_UI1: UINT8 if data.len() < 1 { return Err(HwpError::insufficient_data("UI1", 1, data.len())); } Ok((ParameterItemData::Ui1(UINT8::from_le_bytes([data[0]])), 1)) } ParameterItemType::Ui2 => { // PIT_UI2: UINT16 / PIT_UI2: UINT16 if data.len() < 2 { return Err(HwpError::insufficient_data("UI2", 2, data.len())); } Ok(( ParameterItemData::Ui2(UINT16::from_le_bytes([data[0], data[1]])), 2, )) } ParameterItemType::Ui4 => { // PIT_UI4: UINT32 / PIT_UI4: UINT32 if data.len() < 4 { return Err(HwpError::insufficient_data("UI4", 4, data.len())); } Ok(( ParameterItemData::Ui4(UINT32::from_le_bytes([data[0], data[1], data[2], data[3]])), 4, )) } ParameterItemType::Ui => { // PIT_UI: UINT8 / PIT_UI: UINT8 if data.len() < 1 { return Err(HwpError::insufficient_data("UI", 1, data.len())); } Ok((ParameterItemData::Ui(UINT8::from_le_bytes([data[0]])), 1)) } ParameterItemType::Set => { // PIT_SET: Parameter Set / PIT_SET: Parameter Set // 재귀적으로 파싱 / Parse recursively let parameter_set = ParameterSet::parse(data) .map_err(\|e\| HwpError::from(e))?; // 사용된 바이트 수 계산 (대략적으로) / Calculate bytes consumed (approximately) let size = 4 + parameter_set.items.iter().map(\|_\| 4).sum::<usize>(); // 최소 크기 / Minimum size Ok((ParameterItemData::Set(parameter_set), size)) } ParameterItemType::Array => { // PIT_ARRAY: ParameterArray / PIT_ARRAY: ParameterArray // INT16 파라미터 셋 개수 + Parameter Set 배열 / INT16 parameter set count + Parameter Set array if data.len() < 2 { return Err(HwpError::insufficient_data("Array count", 2, data.len())); } let array_count = INT16::from_le_bytes([data[0], data[1]]) as usize; let mut offset = 2; let mut parameter_sets = Vec::new(); for _ in 0..array_count { if offset >= data.len() { break; } match ParameterSet::parse(&data[offset..]) { Ok(set) => { // 대략적인 크기 계산 / Approximate size calculation let set_size = 4 + set.items.len() * 4; offset += set_size; parameter_sets.push(set); } Err(e) => { #[cfg(debug_assertions)] eprintln!("Failed to parse parameter set in array: {}", e); break; } } } Ok((ParameterItemData::Array(parameter_sets), offset)) } ParameterItemType::Bindata => { // PIT_BINDATA: UINT16 바이너리 데이터 ID / PIT_BINDATA: UINT16 binary data ID if data.len() < 2 { return Err(HwpError::insufficient_data("Bindata", 2, data.len())); } Ok(( ParameterItemData::Bindata(UINT16::from_le_bytes([data[0], data[1]])), 2, )) } } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/para_shape.rs	crates/hwp-core/src/document/docinfo/para_shape.rs	/// ParaShape 구조체 / ParaShape structure /// /// 스펙 문서 매핑: 표 43 - 문단 모양 / Spec mapping: Table 43 - Paragraph shape /// Tag ID: HWPTAG_PARA_SHAPE /// 전체 길이: 54바이트 / Total length: 54 bytes use crate::error::HwpError; use crate::types::{INT16, INT32, UINT16, UINT32, UINT8}; use serde::{Deserialize, Serialize}; /// 문단 모양 속성1 / Paragraph shape attributes 1 #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ParaShapeAttributes1 { /// 줄 간격 종류(한글 2007 이하 버전) / Line spacing type (HWP 2007 and below) pub line_spacing_type_old: LineSpacingTypeOld, /// 정렬 방법 / Alignment method pub align: ParagraphAlignment, /// 줄 나눔 기준 영문 단위 / Line break unit for English pub line_divide_en: LineDivideUnit, /// 줄 나눔 기준 한글 단위 / Line break unit for Korean pub line_divide_ko: LineDivideUnit, /// 편집 용지의 줄 격자 사용 여부 / Use line grid of editing paper pub use_line_grid: bool, /// 최소 공백 값(0%~75%) / Minimum blank value (0%~75%) pub blank_min_value: UINT8, /// 외톨이 줄 보호 / Protect orphan line pub protect_orphan_line: bool, /// 다음 문단과 함께 / With next paragraph pub with_next_paragraph: bool, /// 문단 보호 / Protect paragraph pub protect_paragraph: bool, /// 문단 앞에서 항상 쪽 나눔 / Always page break before paragraph pub always_page_break_before: bool, /// 세로 정렬 / Vertical alignment pub vertical_align: VerticalAlignment, /// 글꼴에 맞는 줄 높이 / Line height matches font pub line_height_matches_font: bool, /// 문단 머리 모양 종류 / Paragraph header shape type pub header_shape_type: HeaderShapeType, /// 문단 수준(1~7) / Paragraph level (1~7) pub paragraph_level: UINT8, /// 문단 테두리 연결 / Connect paragraph border pub connect_border: bool, /// 문단 여백 무시 / Ignore paragraph margin pub ignore_margin: bool, /// 문단 꼬리 모양 / Paragraph tail shape pub tail_shape: bool, } /// 줄 간격 종류(한글 2007 이하 버전) / Line spacing type (HWP 2007 and below) #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum LineSpacingTypeOld { /// 글자에 따라(%) / By character (%) ByCharacter = 0, /// 고정값 / Fixed value Fixed = 1, /// 여백만 지정 / Margin only MarginOnly = 2, } impl LineSpacingTypeOld { fn from_bits(bits: u32) -> Self { match bits & 0x00000003 { 1 => LineSpacingTypeOld::Fixed, 2 => LineSpacingTypeOld::MarginOnly, _ => LineSpacingTypeOld::ByCharacter, } } } /// 정렬 방법 / Alignment method #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum ParagraphAlignment { /// 양쪽 정렬 / Justify Justify = 0, /// 왼쪽 / Left Left = 1, /// 오른쪽 / Right Right = 2, /// 가운데 / Center Center = 3, /// 배분 / Distribute Distribute = 4, /// 나눔 / Divide Divide = 5, } impl ParagraphAlignment { fn from_bits(bits: u32) -> Self { match (bits >> 2) & 0x00000007 { 1 => ParagraphAlignment::Left, 2 => ParagraphAlignment::Right, 3 => ParagraphAlignment::Center, 4 => ParagraphAlignment::Distribute, 5 => ParagraphAlignment::Divide, _ => ParagraphAlignment::Justify, } } } /// 줄 나눔 기준 단위 / Line break unit #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum LineDivideUnit { /// 단어 / Word Word = 0, /// 하이픈 / Hyphen Hyphen = 1, /// 글자 / Character Character = 2, } impl LineDivideUnit { fn from_bits_en(bits: u32) -> Self { match (bits >> 5) & 0x00000003 { 1 => LineDivideUnit::Hyphen, 2 => LineDivideUnit::Character, _ => LineDivideUnit::Word, } } fn from_bit_ko(bit: bool) -> Self { if bit { LineDivideUnit::Character } else { LineDivideUnit::Word } } } /// 세로 정렬 / Vertical alignment #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum VerticalAlignment { /// 글꼴 기준선 / Font baseline Baseline = 0, /// 위 / Top Top = 1, /// 가운데 / Center Center = 2, /// 아래 / Bottom Bottom = 3, } impl VerticalAlignment { fn from_bits(bits: u32) -> Self { match (bits >> 20) & 0x00000003 { 1 => VerticalAlignment::Top, 2 => VerticalAlignment::Center, 3 => VerticalAlignment::Bottom, _ => VerticalAlignment::Baseline, } } } /// 문단 머리 모양 종류 / Paragraph header shape type #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum HeaderShapeType { /// 없음 / None None = 0, /// 개요 / Outline Outline = 1, /// 번호 / Number Number = 2, /// 글머리표 / Bullet Bullet = 3, } impl HeaderShapeType { fn from_bits(bits: u32) -> Self { match (bits >> 23) & 0x00000003 { 1 => HeaderShapeType::Outline, 2 => HeaderShapeType::Number, 3 => HeaderShapeType::Bullet, _ => HeaderShapeType::None, } } } /// 문단 모양 속성2 / Paragraph shape attributes 2 #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ParaShapeAttributes2 { /// 한 줄 입력 / Single line input pub single_line_input: UINT8, /// 한글과 영문 사이 자동 간격 조정 / Auto spacing adjustment between Korean and English pub auto_spacing_ko_en: bool, /// 한글과 숫자 사이 자동 간격 조정 / Auto spacing adjustment between Korean and number pub auto_spacing_ko_num: bool, } /// 줄 간격 종류 (5.0.2.5 이상) / Line spacing type (5.0.2.5+) #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum LineSpacingType { /// 글자에 따라 / By character ByCharacter = 0, /// 고정값 / Fixed value Fixed = 1, /// 여백만 지정 / Margin only MarginOnly = 2, /// 최소값 / Minimum value Minimum = 3, } impl LineSpacingType { fn from_bits(bits: u32) -> Self { match bits & 0x0000001F { 1 => LineSpacingType::Fixed, 2 => LineSpacingType::MarginOnly, 3 => LineSpacingType::Minimum, _ => LineSpacingType::ByCharacter, } } } /// 문단 모양 속성3 / Paragraph shape attributes 3 #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ParaShapeAttributes3 { /// 줄 간격 종류 (bit 0-4, 표 46 참조) / Line spacing type (bit 0-4, See Table 46) pub line_spacing_type: LineSpacingType, } /// ParaShape 구조체 / ParaShape structure #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ParaShape { /// 속성1 (표 44) / Attributes 1 (Table 44) pub attributes1: ParaShapeAttributes1, /// 왼쪽 여백 / Left margin pub left_margin: INT32, /// 오른쪽 여백 / Right margin pub right_margin: INT32, /// 들여쓰기 / Indent pub indent: INT32, /// 내어쓰기 / Outdent pub outdent: INT32, /// 문단 위 간격 / Paragraph top spacing pub top_spacing: INT32, /// 문단 아래 간격 / Paragraph bottom spacing pub bottom_spacing: INT32, /// 줄 간격(한글 2007 이하 버전) / Line spacing (HWP 2007 and below) pub line_spacing_old: INT32, /// 탭 정의 ID 참조 값 / Tab definition ID reference pub tab_def_id: UINT16, /// 번호/글머리표 ID 참조 값 / Number/bullet ID reference pub number_bullet_id: UINT16, /// 테두리/배경 ID 참조 값 / Border/fill ID reference pub border_fill_id: UINT16, /// 문단 테두리 간격(왼쪽) / Paragraph border spacing (left) pub border_spacing_left: INT16, /// 문단 테두리 간격(오른쪽) / Paragraph border spacing (right) pub border_spacing_right: INT16, /// 문단 테두리 간격(위) / Paragraph border spacing (top) pub border_spacing_top: INT16, /// 문단 테두리 간격(아래) / Paragraph border spacing (bottom) pub border_spacing_bottom: INT16, /// 속성2 (표 45, 5.0.1.7 이상, 옵션) / Attributes 2 (Table 45, 5.0.1.7+, optional) pub attributes2: Option<ParaShapeAttributes2>, /// 속성3 (표 46, 5.0.2.5 이상, 옵션) / Attributes 3 (Table 46, 5.0.2.5+, optional) pub attributes3: Option<ParaShapeAttributes3>, /// 줄 간격(5.0.2.5 이상, 옵션) / Line spacing (5.0.2.5+, optional) pub line_spacing: Option<INT32>, } impl ParaShape { /// ParaShape을 바이트 배열에서 파싱합니다. / Parse ParaShape from byte array. /// /// # Arguments /// * `data` - ParaShape 레코드 데이터 / ParaShape record data /// * `version` - HWP 파일 버전 (5.0.1.7 이상에서 속성2 지원, 5.0.2.5 이상에서 속성3 및 줄 간격 지원) / HWP file version (attributes2 supported in 5.0.1.7+, attributes3 and line spacing in 5.0.2.5+) /// /// # Returns /// 파싱된 ParaShape 구조체 / Parsed ParaShape structure pub fn parse(data: &[u8], version: u32) -> Result<Self, HwpError> { // 최소 46바이트 필요 (속성1 4 + 여백/간격 28 + ID 6 + 테두리 간격 8) / Need at least 46 bytes if data.len() < 46 { return Err(HwpError::insufficient_data("ParaShape", 46, data.len())); } let mut offset = 0; // UINT32 속성1 (표 44) / UINT32 attributes1 (Table 44) let attr1_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let attributes1 = ParaShapeAttributes1 { line_spacing_type_old: LineSpacingTypeOld::from_bits(attr1_value), align: ParagraphAlignment::from_bits(attr1_value), line_divide_en: LineDivideUnit::from_bits_en(attr1_value), line_divide_ko: LineDivideUnit::from_bit_ko((attr1_value & 0x00000080) != 0), use_line_grid: (attr1_value & 0x00000100) != 0, blank_min_value: ((attr1_value >> 9) & 0x0000007F) as UINT8, protect_orphan_line: (attr1_value & 0x00010000) != 0, with_next_paragraph: (attr1_value & 0x00020000) != 0, protect_paragraph: (attr1_value & 0x00040000) != 0, always_page_break_before: (attr1_value & 0x00080000) != 0, vertical_align: VerticalAlignment::from_bits(attr1_value), line_height_matches_font: (attr1_value & 0x00400000) != 0, header_shape_type: HeaderShapeType::from_bits(attr1_value), paragraph_level: ((attr1_value >> 25) & 0x00000007) as UINT8, connect_border: (attr1_value & 0x10000000) != 0, ignore_margin: (attr1_value & 0x20000000) != 0, tail_shape: (attr1_value & 0x40000000) != 0, }; // INT32 왼쪽 여백 / INT32 left margin let left_margin = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // INT32 오른쪽 여백 / INT32 right margin let right_margin = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // INT32 들여쓰기 / INT32 indent let indent = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // INT32 내어쓰기 / INT32 outdent let outdent = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // INT32 문단 위 간격 / INT32 paragraph top spacing let top_spacing = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // INT32 문단 아래 간격 / INT32 paragraph bottom spacing let bottom_spacing = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // INT32 줄 간격(한글 2007 이하 버전) / INT32 line spacing (HWP 2007 and below) let line_spacing_old = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // UINT16 탭 정의 ID 참조 값 / UINT16 tab definition ID reference let tab_def_id = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT16 번호/글머리표 ID 참조 값 / UINT16 number/bullet ID reference let number_bullet_id = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT16 테두리/배경 ID 참조 값 / UINT16 border/fill ID reference let border_fill_id = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // INT16 문단 테두리 간격(왼쪽) / INT16 paragraph border spacing (left) let border_spacing_left = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // INT16 문단 테두리 간격(오른쪽) / INT16 paragraph border spacing (right) let border_spacing_right = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // INT16 문단 테두리 간격(위) / INT16 paragraph border spacing (top) let border_spacing_top = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // INT16 문단 테두리 간격(아래) / INT16 paragraph border spacing (bottom) let border_spacing_bottom = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT32 속성2 (표 45, 5.0.1.7 이상) / UINT32 attributes2 (Table 45, 5.0.1.7+) let attributes2 = if version >= 0x00010107 && offset + 4 <= data.len() { let attr2_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; Some(ParaShapeAttributes2 { single_line_input: (attr2_value & 0x00000003) as UINT8, auto_spacing_ko_en: (attr2_value & 0x00000010) != 0, auto_spacing_ko_num: (attr2_value & 0x00000020) != 0, }) } else { None }; // UINT32 속성3 (표 46, 5.0.2.5 이상) / UINT32 attributes3 (Table 46, 5.0.2.5+) let attributes3 = if version >= 0x00020500 && offset + 4 <= data.len() { let attr3_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; Some(ParaShapeAttributes3 { line_spacing_type: LineSpacingType::from_bits(attr3_value), }) } else { None }; // INT32 줄 간격(5.0.2.5 이상) / INT32 line spacing (5.0.2.5+) let line_spacing = if version >= 0x00020500 && offset + 4 <= data.len() { let value = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; Some(value) } else { None }; Ok(ParaShape { attributes1, left_margin, right_margin, indent, outdent, top_spacing, bottom_spacing, line_spacing_old, tab_def_id, number_bullet_id, border_fill_id, border_spacing_left, border_spacing_right, border_spacing_top, border_spacing_bottom, attributes2, attributes3, line_spacing, }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/layout_compatibility.rs	crates/hwp-core/src/document/docinfo/layout_compatibility.rs	/// LayoutCompatibility 구조체 / LayoutCompatibility structure /// /// 스펙 문서 매핑: 표 56 - 레이아웃 호환성 / Spec mapping: Table 56 - Layout compatibility use crate::error::HwpError; use crate::types::UINT32; use serde::{Deserialize, Serialize}; /// 레이아웃 호환성 (표 56) / Layout compatibility (Table 56) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct LayoutCompatibility { /// 글자 단위 서식 / Character unit format pub character_format: UINT32, /// 문단 단위 서식 / Paragraph unit format pub paragraph_format: UINT32, /// 구역 단위 서식 / Section unit format pub section_format: UINT32, /// 개체 단위 서식 / Object unit format pub object_format: UINT32, /// 필드 단위 서식 / Field unit format pub field_format: UINT32, } impl LayoutCompatibility { /// LayoutCompatibility를 바이트 배열에서 파싱합니다. / Parse LayoutCompatibility from byte array. /// /// # Arguments /// * `data` - LayoutCompatibility 데이터 (20바이트) / LayoutCompatibility data (20 bytes) /// /// # Returns /// 파싱된 LayoutCompatibility 구조체 / Parsed LayoutCompatibility structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 20 { return Err(HwpError::insufficient_data("LayoutCompatibility", 20, data.len())); } Ok(LayoutCompatibility { character_format: UINT32::from_le_bytes([data[0], data[1], data[2], data[3]]), paragraph_format: UINT32::from_le_bytes([data[4], data[5], data[6], data[7]]), section_format: UINT32::from_le_bytes([data[8], data[9], data[10], data[11]]), object_format: UINT32::from_le_bytes([data[12], data[13], data[14], data[15]]), field_format: UINT32::from_le_bytes([data[16], data[17], data[18], data[19]]), }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/forbidden_char.rs	crates/hwp-core/src/document/docinfo/forbidden_char.rs	/// ForbiddenChar 구조체 / ForbiddenChar structure /// /// 스펙 문서 매핑: 표 4 - 금칙처리 문자 / Spec mapping: Table 4 - Forbidden character /// 상세 구조는 스펙 문서에 명시되지 않음 / Detailed structure not specified in spec use crate::error::HwpError; use serde::{Deserialize, Serialize}; /// 금칙처리 문자 / Forbidden character #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ForbiddenChar { /// Raw data (가변) / Raw data (variable) #[serde(skip)] pub raw_data: Vec<u8>, } impl ForbiddenChar { /// ForbiddenChar를 바이트 배열에서 파싱합니다. / Parse ForbiddenChar from byte array. /// /// # Arguments /// * `data` - ForbiddenChar 데이터 (가변) / ForbiddenChar data (variable) /// /// # Returns /// 파싱된 ForbiddenChar 구조체 / Parsed ForbiddenChar structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { Ok(ForbiddenChar { raw_data: data.to_vec(), }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/memo_list.rs	crates/hwp-core/src/document/bodytext/memo_list.rs	/// MemoList 구조체 / MemoList structure /// /// 구현 상태 / Implementation Status /// - 구현 완료 / Implementation complete /// - 스펙 문서에 상세 구조가 명시되어 있지 않음 / Spec document does not specify detailed structure /// - 테스트 파일(`noori.hwp`)에 MEMO_LIST 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain MEMO_LIST records use crate::error::HwpError; use serde::{Deserialize, Serialize}; /// 메모 리스트 헤더 / Memo list header #[derive(Debug, Clone, Serialize, Deserialize)] pub struct MemoList { /// Raw 데이터 / Raw data /// 스펙 문서에 상세 구조가 명시되어 있지 않으므로 raw 데이터로 저장합니다. /// Raw data is stored because the spec document does not specify detailed structure. #[serde(skip_serializing_if = "Vec::is_empty")] pub raw_data: Vec<u8>, } impl MemoList { /// MemoList을 바이트 배열에서 파싱합니다. / Parse MemoList from byte array. /// /// # Arguments /// * `data` - MemoList 데이터 / MemoList data /// /// # Returns /// 파싱된 MemoList 구조체 / Parsed MemoList structure /// /// # Note /// 스펙 문서 표 57에는 "메모 리스트 헤더"로만 언급되어 있고 상세 구조가 명시되어 있지 않습니다. /// 레거시 코드(hwp.js)도 raw 데이터로만 저장하고 있습니다. /// Spec document Table 57 only mentions "Memo list header" and does not specify detailed structure. /// Legacy code (hwp.js) also stores only raw data. /// /// 테스트 상태 / Testing Status /// 현재 테스트 파일(`noori.hwp`)에 MEMO_LIST 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 MEMO_LIST 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain MEMO_LIST records, so it has not been verified with actual files. /// If an actual HWP file contains MEMO_LIST records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { Ok(MemoList { raw_data: data.to_vec(), }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/eqedit.rs	crates/hwp-core/src/document/bodytext/eqedit.rs	/// EqEdit 구조체 / EqEdit structure /// /// 스펙 문서 매핑: 표 105 - 수식 개체 속성 / Spec mapping: Table 105 - Equation editor object attributes /// /// 구현 상태 / Implementation Status /// - 구현 완료 / Implementation complete /// - 테스트 파일(`noori.hwp`)에 EQEDIT 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain EQEDIT records use crate::error::HwpError; use crate::types::{decode_utf16le, COLORREF, HWPUNIT, INT16, UINT16, UINT32}; use serde::{Deserialize, Serialize}; /// 수식 개체 / Equation editor object #[derive(Debug, Clone, Serialize, Deserialize)] pub struct EqEdit { /// 속성. 스크립트가 차지하는 범위. 첫 비트가 켜져 있으면 줄 단위, 꺼져 있으면 글자 단위. /// Attribute. Range occupied by script. If first bit is set, line unit; otherwise, character unit. pub attribute: UINT32, /// 스크립트 길이 / Script length pub script_length: UINT16, /// 한글 수식 스크립트 / HWP equation script (EQN script compatible) pub script: String, /// 수식 글자 크기 / Equation character size pub character_size: HWPUNIT, /// 글자 색상 / Character color pub character_color: COLORREF, /// base line / Base line pub base_line: INT16, /// 수식 버전 정보 / Equation version information pub version_info: String, /// 수식 폰트 이름 / Equation font name pub font_name: String, } impl EqEdit { /// EqEdit을 바이트 배열에서 파싱합니다. / Parse EqEdit from byte array. /// /// # Arguments /// * `data` - EqEdit 데이터 (수식 개체 속성 부분만) / EqEdit data (equation editor object attributes only) /// /// # Returns /// 파싱된 EqEdit 구조체 / Parsed EqEdit structure /// /// # Note /// 스펙 문서 표 104에 따르면 EQEDIT는 다음 구조를 가집니다: /// - 개체 공통 속성(표 68 참조) - 가변 길이 /// - 수식 개체 속성(표 105 참조) - 가변 길이 (16 + 6×len 바이트) /// /// 레거시 코드(hwp.js)는 수식 개체 속성의 일부만 파싱하고 있습니다. /// According to spec Table 104, EQEDIT has the following structure: /// - Object common properties (Table 68) - variable length /// - Equation editor object attributes (Table 105) - variable length (16 + 6×len bytes) /// /// Legacy code (hwp.js) only parses part of equation editor object attributes. /// /// 테스트 상태 / Testing Status /// 현재 테스트 파일(`noori.hwp`)에 EQEDIT 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 EQEDIT 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain EQEDIT records, so it has not been verified with actual files. /// If an actual HWP file contains EQEDIT records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // 최소 16바이트 필요 (len=0일 때) / Need at least 16 bytes (when len=0) if data.len() < 16 { return Err(HwpError::insufficient_data("EqEdit", 16, data.len())); } let mut offset = 0; // 표 105: 속성 (UINT32, 4바이트) / Table 105: Attribute (UINT32, 4 bytes) let attribute = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 105: 스크립트 길이 (WORD, 2바이트) / Table 105: Script length (WORD, 2 bytes) let script_length = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let script_length_usize = script_length as usize; // 필요한 바이트 수 계산 / Calculate required bytes // UINT32(4) + WORD(2) + WCHAR array[len](2×len) + HWPUNIT(4) + COLORREF(4) + INT16(2) + WCHAR array[len](2×len) + WCHAR array[len](2×len) // = 16 + 6×len let required_bytes = 16 + 6 * script_length_usize; if data.len() < required_bytes { return Err(HwpError::InsufficientData { field: format!("EqEdit (script_length={})", script_length_usize), expected: required_bytes, actual: data.len(), }); } // 표 105: 한글 수식 스크립트 (WCHAR array[len], 2×len 바이트) / Table 105: HWP equation script (WCHAR array[len], 2×len bytes) let script_bytes = &data[offset..offset + 2 * script_length_usize]; let script = decode_utf16le(script_bytes) .map_err(\|e\| HwpError::EncodingError { reason: format!("Failed to decode EqEdit script: {}", e), })?; offset += 2 * script_length_usize; // 표 105: 수식 글자 크기 (HWPUNIT, 4바이트) / Table 105: Equation character size (HWPUNIT, 4 bytes) let character_size_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); let character_size = HWPUNIT::from(character_size_value); offset += 4; // 표 105: 글자 색상 (COLORREF, 4바이트) / Table 105: Character color (COLORREF, 4 bytes) let color_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); let character_color = COLORREF(color_value); offset += 4; // 표 105: base line (INT16, 2바이트) / Table 105: Base line (INT16, 2 bytes) let base_line = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // 표 105: 수식 버전 정보 (WCHAR array[len], 2×len 바이트) / Table 105: Equation version information (WCHAR array[len], 2×len bytes) let version_bytes = &data[offset..offset + 2 * script_length_usize]; let version_info = decode_utf16le(version_bytes) .map_err(\|e\| HwpError::EncodingError { reason: format!("Failed to decode EqEdit version_info: {}", e), })?; offset += 2 * script_length_usize; // 표 105: 수식 폰트 이름 (WCHAR array[len], 2×len 바이트) / Table 105: Equation font name (WCHAR array[len], 2×len bytes) let font_bytes = &data[offset..offset + 2 * script_length_usize]; let font_name = decode_utf16le(font_bytes) .map_err(\|e\| HwpError::EncodingError { reason: format!("Failed to decode EqEdit font_name: {}", e), })?; offset += 2 * script_length_usize; Ok(EqEdit { attribute, script_length, script, character_size, character_color, base_line, version_info, font_name, }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/record_tree.rs	crates/hwp-core/src/document/bodytext/record_tree.rs	/// 레코드 트리 구조 / Record tree structure /// /// HWP 레코드는 계층 구조로 저장되며, 레벨 정보를 통해 트리 구조를 재구성할 수 있습니다. /// HWP records are stored in a hierarchical structure, and the tree structure can be reconstructed using level information. use crate::error::HwpError; use crate::types::RecordHeader; /// 레코드 트리 노드 / Record tree node #[derive(Debug, Clone)] pub struct RecordTreeNode { /// 레코드 헤더 / Record header pub header: RecordHeader, /// 레코드 데이터 / Record data pub data: Vec<u8>, /// 자식 노드들 / Child nodes pub children: Vec<RecordTreeNode>, } impl RecordTreeNode { /// 레코드 트리를 파싱합니다. / Parse record tree. /// /// hwp.js의 parseRecordTree 로직을 정확히 따라갑니다: /// Follows hwp.js's parseRecordTree logic exactly: /// ```typescript /// let parent: HWPRecord = root /// for (let i = 0; i < level; i += 1) { /// parent = parent.children.slice(-1).pop()! /// } /// parent.children.push(new HWPRecord(...)) /// ``` /// /// # Arguments /// * `data` - Section의 원시 바이트 데이터 / Raw byte data of section /// /// # Returns /// 루트 노드 (레벨 0 레코드들이 자식으로 포함됨) / Root node (level 0 records are included as children) pub fn parse_tree(data: &[u8]) -> Result<RecordTreeNode, HwpError> { let root = RecordTreeNode { header: RecordHeader { tag_id: 0, level: 0, size: 0, has_extended_size: false, }, data: Vec::new(), children: Vec::new(), }; let mut offset = 0; // 스택: 각 레벨의 마지막 노드 참조를 저장 / Stack: stores reference to last node at each level // hwp.js 방식: for (let i = 0; i < level; i += 1) { parent = parent.children.slice(-1).pop()! } // hwp.js way: for (let i = 0; i < level; i += 1) { parent = parent.children.slice(-1).pop()! } // 스택[i]는 레벨 i의 마지막 노드 인덱스 / stack[i] is the last node index at level i // 레벨 i의 부모는 스택[i-1] (레벨 0의 부모는 루트) / Parent of level i is stack[i-1] (parent of level 0 is root) let mut stack: Vec<usize> = Vec::new(); // 각 레벨의 마지막 노드 인덱스 / Last node index at each level let mut nodes: Vec<(RecordTreeNode, Vec<usize>)> = Vec::new(); // (노드, 자식 인덱스 리스트) / (node, child indices) nodes.push((root, Vec::new())); while offset < data.len() { // 레코드 헤더 파싱 / Parse record header let remaining_data = &data[offset..]; let (header, header_size) = RecordHeader::parse(remaining_data) .map_err(\|e\| HwpError::from(e))?; offset += header_size; // 데이터 영역 읽기 / Read data area let data_size = header.size as usize; if offset + data_size > data.len() { return Err(HwpError::InsufficientData { field: format!("Record at offset {}", offset), expected: offset + data_size, actual: data.len(), }); } let record_data = &data[offset..offset + data_size]; offset += data_size; // 새 노드 생성 / Create new node let new_node = RecordTreeNode { header, data: record_data.to_vec(), children: Vec::new(), }; let new_node_index = nodes.len(); nodes.push((new_node, Vec::new())); // 부모 노드 찾기: hwp.js 로직 정확히 따라가기 // Find parent node: follow hwp.js logic exactly // hwp.js: for (let i = 0; i < level; i += 1) { parent = parent.children.slice(-1).pop()! } // 즉, 레벨만큼 깊이 들어가서 마지막 자식을 부모로 선택 // That is, go level deep and select the last child as parent // 스택을 레벨에 맞게 조정: 레벨이 감소하면 상위 레벨로 돌아감 // Adjust stack to match level: if level decreases, return to higher level while stack.len() > header.level as usize { stack.pop(); } // 부모 노드 찾기 / Find parent node let parent_index = if header.level == 0 { 0 // 루트 / Root } else { // 스택을 레벨에 맞게 확장 / Expand stack to match level while stack.len() < header.level as usize { // 스택이 부족하면 이전 레벨의 마지막 노드를 사용 / Use last node of previous level if stack is insufficient if let Some(&last) = stack.last() { stack.push(last); } else { stack.push(0); // 루트 / Root } } // 레벨 i의 부모는 레벨 i-1의 마지막 노드 (스택[i-1]) // Parent of level i is last node at level i-1 (stack[i-1]) stack[header.level as usize - 1] }; // 부모에 자식 추가 / Add child to parent nodes[parent_index].1.push(new_node_index); // 새 노드를 스택에 추가 (다음 레코드의 부모가 될 수 있음) // Add new node to stack (can be parent of next record) // 스택을 레벨 크기로 확장 / Expand stack to level size while stack.len() <= header.level as usize { stack.push(0); // 플레이스홀더 / Placeholder } stack[header.level as usize] = new_node_index; } // 인덱스 기반 트리를 실제 트리로 변환 / Convert index-based tree to actual tree fn build_tree(nodes: &[(RecordTreeNode, Vec<usize>)], index: usize) -> RecordTreeNode { let (node, children_indices) = &nodes[index]; let mut result = RecordTreeNode { header: node.header, data: node.data.clone(), children: Vec::new(), }; for &child_index in children_indices { result.children.push(build_tree(nodes, child_index)); } result } Ok(build_tree(&nodes, 0)) } /// 태그 ID 반환 / Get tag ID pub fn tag_id(&self) -> u16 { self.header.tag_id } /// 레벨 반환 / Get level pub fn level(&self) -> u16 { self.header.level } /// 데이터 반환 / Get data pub fn data(&self) -> &[u8] { &self.data } /// 자식 노드들 반환 / Get children pub fn children(&self) -> &[RecordTreeNode] { &self.children } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/line_seg.rs	crates/hwp-core/src/document/bodytext/line_seg.rs	/// LineSegmentInfo 구조체 / LineSegmentInfo structure /// /// 스펙 문서 매핑: 표 62 - 문단의 레이아웃 / Spec mapping: Table 62 - Paragraph line segment /// 각 항목: 36바이트 use crate::error::HwpError; use crate::types::{INT32, UINT32}; use serde::{Deserialize, Serialize}; /// 줄 세그먼트 태그 플래그 / Line segment tag flags #[derive(Debug, Clone, Serialize, Deserialize)] pub struct LineSegmentTag { /// 페이지의 첫 줄인지 여부 / Is first line of page pub is_first_line_of_page: bool, /// 컬럼의 첫 줄인지 여부 / Is first line of column pub is_first_line_of_column: bool, /// 텍스트가 배열되지 않은 빈 세그먼트인지 여부 / Is empty segment without text pub is_empty_segment: bool, /// 줄의 첫 세그먼트인지 여부 / Is first segment of line pub is_first_segment_of_line: bool, /// 줄의 마지막 세그먼트인지 여부 / Is last segment of line pub is_last_segment_of_line: bool, /// 줄의 마지막에 auto-hyphenation이 수행되었는지 여부 / Auto-hyphenation performed at end of line pub has_auto_hyphenation: bool, /// indentation 적용 / Indentation applied pub has_indentation: bool, /// 문단 머리 모양 적용 / Paragraph header shape applied pub has_paragraph_header_shape: bool, } impl LineSegmentTag { /// UINT32 태그 값에서 LineSegmentTag를 파싱합니다. / Parse LineSegmentTag from UINT32 tag value. fn from_bits(tag: UINT32) -> Self { LineSegmentTag { is_first_line_of_page: (tag & 0x00000001) != 0, is_first_line_of_column: (tag & 0x00000002) != 0, is_empty_segment: (tag & 0x00010000) != 0, is_first_segment_of_line: (tag & 0x00020000) != 0, is_last_segment_of_line: (tag & 0x00040000) != 0, has_auto_hyphenation: (tag & 0x00080000) != 0, has_indentation: (tag & 0x00100000) != 0, has_paragraph_header_shape: (tag & 0x00200000) != 0, } } } /// 줄 세그먼트 정보 / Line segment information #[derive(Debug, Clone, Serialize, Deserialize)] pub struct LineSegmentInfo { /// 텍스트 시작 위치 / Text start position pub text_start_position: UINT32, /// 줄의 세로 위치 / Vertical position of line pub vertical_position: INT32, /// 줄의 높이 / Height of line pub line_height: INT32, /// 텍스트 부분의 높이 / Height of text portion pub text_height: INT32, /// 줄의 세로 위치에서 베이스라인까지 거리 / Distance from vertical position to baseline pub baseline_distance: INT32, /// 줄간격 / Line spacing pub line_spacing: INT32, /// 컬럼에서의 시작 위치 / Start position in column pub column_start_position: INT32, /// 세그먼트의 폭 / Width of segment pub segment_width: INT32, /// 태그 (플래그들) / Tag (flags) pub tag: LineSegmentTag, } impl LineSegmentInfo { /// LineSegmentInfo를 바이트 배열에서 파싱합니다. / Parse LineSegmentInfo from byte array. /// /// # Arguments /// * `data` - 최소 36바이트의 데이터 / At least 36 bytes of data /// /// # Returns /// 파싱된 LineSegmentInfo 구조체 / Parsed LineSegmentInfo structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 36 { return Err(HwpError::insufficient_data("LineSegmentInfo", 36, data.len())); } let mut offset = 0; // UINT32 텍스트 시작 위치 / UINT32 text start position let text_start_position = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // INT32 줄의 세로 위치 / INT32 vertical position of line let vertical_position = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // INT32 줄의 높이 / INT32 height of line let line_height = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // INT32 텍스트 부분의 높이 / INT32 height of text portion let text_height = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // INT32 줄의 세로 위치에서 베이스라인까지 거리 / INT32 distance from vertical position to baseline let baseline_distance = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // INT32 줄간격 / INT32 line spacing let line_spacing = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // INT32 컬럼에서의 시작 위치 / INT32 start position in column let column_start_position = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // INT32 세그먼트의 폭 / INT32 width of segment let segment_width = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // UINT32 태그 / UINT32 tag let tag_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); let tag = LineSegmentTag::from_bits(tag_value); Ok(LineSegmentInfo { text_start_position, vertical_position, line_height, text_height, baseline_distance, line_spacing, column_start_position, segment_width, tag, }) } } /// 문단의 레이아웃 리스트 / Paragraph line segment list #[derive(Debug, Clone, Default, Serialize, Deserialize)] pub struct ParaLineSeg { /// 줄 세그먼트 정보 리스트 / Line segment information list pub segments: Vec<LineSegmentInfo>, } impl ParaLineSeg { /// ParaLineSeg를 바이트 배열에서 파싱합니다. / Parse ParaLineSeg from byte array. /// /// # Arguments /// * `data` - 레이아웃 데이터 (36×n 바이트) / Line segment data (36×n bytes) /// /// # Returns /// 파싱된 ParaLineSeg 구조체 / Parsed ParaLineSeg structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() % 36 != 0 { return Err(HwpError::UnexpectedValue { field: "ParaLineSeg data length".to_string(), expected: "multiple of 36".to_string(), found: format!("{} bytes", data.len()), }); } let count = data.len() / 36; let mut segments = Vec::with_capacity(count); for i in 0..count { let offset = i * 36; let segment_data = &data[offset..offset + 36]; let segment_info = LineSegmentInfo::parse(segment_data) .map_err(\|e\| HwpError::from(e))?; segments.push(segment_info); } Ok(ParaLineSeg { segments }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/char_shape.rs	crates/hwp-core/src/document/bodytext/char_shape.rs	/// CharShapeInfo 구조체 / CharShapeInfo structure /// /// 스펙 문서 매핑: 표 61 - 문단의 글자 모양 / Spec mapping: Table 61 - Paragraph character shape /// 각 항목: 8바이트 use crate::error::HwpError; use crate::types::UINT32; use serde::{Deserialize, Serialize}; /// 글자 모양 정보 / Character shape information #[derive(Debug, Clone, Serialize, Deserialize)] pub struct CharShapeInfo { /// 글자 모양이 바뀌는 시작 위치 / Position where character shape changes pub position: UINT32, /// 글자 모양 ID / Character shape ID pub shape_id: UINT32, } impl CharShapeInfo { /// CharShapeInfo를 바이트 배열에서 파싱합니다. / Parse CharShapeInfo from byte array. /// /// # Arguments /// * `data` - 최소 8바이트의 데이터 / At least 8 bytes of data /// /// # Returns /// 파싱된 CharShapeInfo 구조체 / Parsed CharShapeInfo structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 8 { return Err(HwpError::insufficient_data("CharShapeInfo", 8, data.len())); } // UINT32 글자 모양이 바뀌는 시작 위치 / UINT32 position where character shape changes let position = UINT32::from_le_bytes([data[0], data[1], data[2], data[3]]); // UINT32 글자 모양 ID / UINT32 character shape ID let shape_id = UINT32::from_le_bytes([data[4], data[5], data[6], data[7]]); Ok(CharShapeInfo { position, shape_id }) } } /// 문단의 글자 모양 리스트 / Paragraph character shape list #[derive(Debug, Clone, Default, Serialize, Deserialize)] pub struct ParaCharShape { /// 글자 모양 정보 리스트 / Character shape information list pub shapes: Vec<CharShapeInfo>, } impl ParaCharShape { /// ParaCharShape를 바이트 배열에서 파싱합니다. / Parse ParaCharShape from byte array. /// /// # Arguments /// * `data` - 글자 모양 데이터 (8×n 바이트) / Character shape data (8×n bytes) /// /// # Returns /// 파싱된 ParaCharShape 구조체 / Parsed ParaCharShape structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() % 8 != 0 { return Err(HwpError::UnexpectedValue { field: "ParaCharShape data length".to_string(), expected: "multiple of 8".to_string(), found: format!("{} bytes", data.len()), }); } let count = data.len() / 8; let mut shapes = Vec::with_capacity(count); for i in 0..count { let offset = i * 8; let shape_data = &data[offset..offset + 8]; let shape_info = CharShapeInfo::parse(shape_data) .map_err(\|e\| HwpError::from(e))?; shapes.push(shape_info); } Ok(ParaCharShape { shapes }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/page_def.rs	crates/hwp-core/src/document/bodytext/page_def.rs	/// PageDef 구조체 / PageDef structure /// /// 스펙 문서 매핑: 표 131 - 용지 설정 / Spec mapping: Table 131 - Page definition use crate::error::HwpError; use crate::types::{HWPUNIT, UINT32}; use serde::{Deserialize, Serialize}; /// 용지 설정 / Page definition #[derive(Debug, Clone, Serialize, Deserialize)] pub struct PageDef { /// 용지 가로 크기 / Paper width pub paper_width: HWPUNIT, /// 용지 세로 크기 / Paper height pub paper_height: HWPUNIT, /// 용지 왼쪽 여백 / Left margin pub left_margin: HWPUNIT, /// 오른쪽 여백 / Right margin pub right_margin: HWPUNIT, /// 위 여백 / Top margin pub top_margin: HWPUNIT, /// 아래 여백 / Bottom margin pub bottom_margin: HWPUNIT, /// 머리말 여백 / Header margin pub header_margin: HWPUNIT, /// 꼬리말 여백 / Footer margin pub footer_margin: HWPUNIT, /// 제본 여백 / Binding margin pub binding_margin: HWPUNIT, /// 속성 / Attributes pub attributes: PageDefAttributes, } /// 용지 설정 속성 / Page definition attributes #[derive(Debug, Clone, Serialize, Deserialize)] pub struct PageDefAttributes { /// 용지 방향 / Paper direction pub paper_direction: PaperDirection, /// 제책 방법 / Binding method pub binding_method: BindingMethod, } /// 용지 방향 / Paper direction #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum PaperDirection { /// 좁게 (세로) / Vertical (narrow) Vertical, /// 넓게 (가로) / Horizontal (wide) Horizontal, } /// 제책 방법 / Binding method #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum BindingMethod { /// 한쪽 편집 / Single page editing SinglePage, /// 맞쪽 편집 / Facing pages editing FacingPages, /// 위로 넘기기 / Flip up FlipUp, } impl PageDef { /// PageDef를 바이트 배열에서 파싱합니다. / Parse PageDef from byte array. /// /// # Arguments /// * `data` - 최소 40바이트의 데이터 / At least 40 bytes of data /// /// # Returns /// 파싱된 PageDef 구조체 / Parsed PageDef structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 40 { return Err(HwpError::insufficient_data("PageDef", 40, data.len())); } let mut offset = 0; // HWPUNIT 용지 가로 크기 / HWPUNIT paper width let paper_width = HWPUNIT::from(UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; // HWPUNIT 용지 세로 크기 / HWPUNIT paper height let paper_height = HWPUNIT::from(UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; // HWPUNIT 용지 왼쪽 여백 / HWPUNIT left margin let left_margin = HWPUNIT::from(UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; // HWPUNIT 오른쪽 여백 / HWPUNIT right margin let right_margin = HWPUNIT::from(UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; // HWPUNIT 위 여백 / HWPUNIT top margin let top_margin = HWPUNIT::from(UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; // HWPUNIT 아래 여백 / HWPUNIT bottom margin let bottom_margin = HWPUNIT::from(UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; // HWPUNIT 머리말 여백 / HWPUNIT header margin let header_margin = HWPUNIT::from(UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; // HWPUNIT 꼬리말 여백 / HWPUNIT footer margin let footer_margin = HWPUNIT::from(UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; // HWPUNIT 제본 여백 / HWPUNIT binding margin let binding_margin = HWPUNIT::from(UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; // UINT32 속성 (표 132 참조) / UINT32 attributes (see Table 132) let attribute_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); // 속성 파싱 (표 132) / Parse attributes (Table 132) let attributes = parse_page_def_attributes(attribute_value); Ok(PageDef { paper_width, paper_height, left_margin, right_margin, top_margin, bottom_margin, header_margin, footer_margin, binding_margin, attributes, }) } } /// 용지 설정 속성 파싱 (표 132) / Parse page definition attributes (Table 132) fn parse_page_def_attributes(value: UINT32) -> PageDefAttributes { // bit 0: 용지 방향 / bit 0: paper direction // 0: 좁게 (세로) / 0: vertical (narrow) // 1: 넓게 (가로) / 1: horizontal (wide) let paper_direction = if (value & 0x01) == 0 { PaperDirection::Vertical } else { PaperDirection::Horizontal }; // bit 1-2: 제책 방법 / bit 1-2: binding method // 0: 한쪽 편집 / 0: single page editing // 1: 맞쪽 편집 / 1: facing pages editing // 2: 위로 넘기기 / 2: flip up let binding_method = match (value >> 1) & 0x03 { 0 => BindingMethod::SinglePage, 1 => BindingMethod::FacingPages, 2 => BindingMethod::FlipUp, _ => BindingMethod::SinglePage, // 기본값 / default }; PageDefAttributes { paper_direction, binding_method, } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/footnote_shape.rs	crates/hwp-core/src/document/bodytext/footnote_shape.rs	/// FootnoteShape 구조체 / FootnoteShape structure /// /// 스펙 문서 매핑: 표 133 - 각주/미주 모양 / Spec mapping: Table 133 - Footnote/endnote shape use crate::error::HwpError; use crate::types::{COLORREF, HWPUNIT16, UINT16, UINT32, UINT8, WCHAR}; use serde::{Deserialize, Serialize}; /// 각주/미주 모양 / Footnote/endnote shape #[derive(Debug, Clone, Serialize, Deserialize)] pub struct FootnoteShape { /// 속성 / Attributes pub attributes: FootnoteShapeAttributes, /// 사용자 기호 / Custom symbol pub custom_symbol: WCHAR, /// 앞 장식 문자 / Front decoration character pub front_decoration: WCHAR, /// 뒤 장식 문자 / Back decoration character pub back_decoration: WCHAR, /// 시작 번호 / Start number pub start_number: UINT16, /// 구분선 길이 / Breakline length pub breakline_length: HWPUNIT16, /// 구분선 위 여백 / Breakline top margin pub breakline_top_margin: HWPUNIT16, /// 구분선 아래 여백 / Breakline bottom margin pub breakline_bottom_margin: HWPUNIT16, /// 주석 사이 여백 / Remark between margin pub remark_between_margin: HWPUNIT16, /// 구분선 종류 / Breakline type pub breakline_type: UINT8, /// 구분선 굵기 / Breakline thickness pub breakline_thickness: UINT8, /// 구분선 색상 / Breakline color pub breakline_color: COLORREF, } /// 각주/미주 모양 속성 / Footnote/endnote shape attributes #[derive(Debug, Clone, Serialize, Deserialize)] pub struct FootnoteShapeAttributes { /// 번호 모양 / Number shape pub number_shape: NumberShape, /// 한 페이지 내에서 각주를 다단에 위치시킬 방법 / Page position method for footnotes in multi-column pub page_position: PagePosition, /// 번호 매기기 방법 / Numbering method pub numbering: NumberingMethod, /// 각주 내용 중 번호 코드의 모양을 위 첨자 형식으로 할지 여부 / Superscript format for number code in footnote content pub superscript: bool, /// 텍스트에 이어 바로 출력할지 여부 / Output immediately after text pub prefix: bool, } /// 번호 모양 / Number shape #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum NumberShape { /// 1, 2, 3 Arabic, /// 동그라미 쳐진 1, 2, 3 CircledArabic, /// I, II, III RomanUpper, /// i, ii, iii RomanLower, /// A, B, C AlphaUpper, /// a, b, c AlphaLower, /// 동그라미 쳐진 A, B, C CircledAlphaUpper, /// 동그라미 쳐진 a, b, c CircledAlphaLower, /// 가, 나, 다 Hangul, /// 동그라미 쳐진 가, 나, 다 CircledHangul, /// ㄱ, ㄴ, ㄷ HangulJamo, /// 동그라미 쳐진 ㄱ, ㄴ, ㄷ CircledHangulJamo, /// 일, 이, 삼 HangulNumber, /// 一, 二, 三 ChineseNumber, /// 동그라미 쳐진 一, 二, 三 CircledChineseNumber, /// 갑, 을, 병, 정, 무, 기, 경, 신, 임, 계 HeavenlyStem, /// 甲, 乙, 丙, 丁, 戊, 己, 庚, 辛, 壬, 癸 HeavenlyStemChinese, /// 4가지 문자가 차례로 반복 FourCharRepeat, /// 사용자 지정 문자 반복 CustomCharRepeat, } /// 한 페이지 내에서 각주를 다단에 위치시킬 방법 / Page position method for footnotes in multi-column #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum PagePosition { /// (각주인 경우) 각 단마다 따로 배열 / (For footnote) Arrange separately for each column /// (미주인 경우) 문서의 마지막 / (For endnote) End of document Separate, /// (각주인 경우) 통단으로 배열 / (For footnote) Arrange across columns /// (미주인 경우) 구역의 마지막 / (For endnote) End of section Across, /// (각주인 경우) 가장 오른쪽 단에 배열 / (For footnote) Arrange in rightmost column Rightmost, } /// 번호 매기기 방법 / Numbering method #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum NumberingMethod { /// 앞 구역에 이어서 / Continue from previous section Continue, /// 현재 구역부터 새로 시작 / Start from current section Restart, /// 쪽마다 새로 시작(각주 전용) / Restart per page (footnote only) PerPage, } impl FootnoteShape { /// FootnoteShape를 바이트 배열에서 파싱합니다. / Parse FootnoteShape from byte array. /// /// # Arguments /// * `data` - 최소 26바이트의 데이터 / At least 26 bytes of data /// /// # Returns /// 파싱된 FootnoteShape 구조체 / Parsed FootnoteShape structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 26 { return Err(HwpError::insufficient_data("FootnoteShape", 26, data.len())); } let mut offset = 0; // UINT32 속성 (표 134 참조) / UINT32 attributes (see Table 134) let attribute_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 속성 파싱 (표 134) / Parse attributes (Table 134) let attributes = parse_footnote_shape_attributes(attribute_value); // WCHAR 사용자 기호 / WCHAR custom symbol let custom_symbol = WCHAR::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // WCHAR 앞 장식 문자 / WCHAR front decoration character let front_decoration = WCHAR::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // WCHAR 뒤 장식 문자 / WCHAR back decoration character let back_decoration = WCHAR::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT16 시작 번호 / UINT16 start number let start_number = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // HWPUNIT16 구분선 길이 / HWPUNIT16 breakline length let breakline_length = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // HWPUNIT16 구분선 위 여백 / HWPUNIT16 breakline top margin let breakline_top_margin = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // HWPUNIT16 구분선 아래 여백 / HWPUNIT16 breakline bottom margin let breakline_bottom_margin = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // HWPUNIT16 주석 사이 여백 / HWPUNIT16 remark between margin let remark_between_margin = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT8 구분선 종류 / UINT8 breakline type let breakline_type = data[offset]; offset += 1; // UINT8 구분선 굵기 / UINT8 breakline thickness let breakline_thickness = data[offset]; offset += 1; // COLORREF 구분선 색상 / COLORREF breakline color let breakline_color = COLORREF(u32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; Ok(FootnoteShape { attributes, custom_symbol, front_decoration, back_decoration, start_number, breakline_length, breakline_top_margin, breakline_bottom_margin, remark_between_margin, breakline_type, breakline_thickness, breakline_color, }) } } /// 각주/미주 모양 속성 파싱 (표 134) / Parse footnote/endnote shape attributes (Table 134) fn parse_footnote_shape_attributes(value: UINT32) -> FootnoteShapeAttributes { // bit 0-7: 번호 모양 / bit 0-7: number shape let number_shape_value = (value & 0xFF) as u8; let number_shape = match number_shape_value { 0 => NumberShape::Arabic, 1 => NumberShape::CircledArabic, 2 => NumberShape::RomanUpper, 3 => NumberShape::RomanLower, 4 => NumberShape::AlphaUpper, 5 => NumberShape::AlphaLower, 6 => NumberShape::CircledAlphaUpper, 7 => NumberShape::CircledAlphaLower, 8 => NumberShape::Hangul, 9 => NumberShape::CircledHangul, 10 => NumberShape::HangulJamo, 11 => NumberShape::CircledHangulJamo, 12 => NumberShape::HangulNumber, 13 => NumberShape::ChineseNumber, 14 => NumberShape::CircledChineseNumber, 15 => NumberShape::HeavenlyStem, 16 => NumberShape::HeavenlyStemChinese, 0x80 => NumberShape::FourCharRepeat, 0x81 => NumberShape::CustomCharRepeat, _ => NumberShape::Arabic, // 기본값 / default }; // bit 8-9: 한 페이지 내에서 각주를 다단에 위치시킬 방법 / bit 8-9: page position method let page_position = match (value >> 8) & 0x03 { 0 => PagePosition::Separate, 1 => PagePosition::Across, 2 => PagePosition::Rightmost, _ => PagePosition::Separate, // 기본값 / default }; // bit 10-11: numbering / bit 10-11: numbering method let numbering = match (value >> 10) & 0x03 { 0 => NumberingMethod::Continue, 1 => NumberingMethod::Restart, 2 => NumberingMethod::PerPage, _ => NumberingMethod::Continue, // 기본값 / default }; // bit 12: 각주 내용 중 번호 코드의 모양을 위 첨자 형식으로 할지 여부 / bit 12: superscript format let superscript = (value & 0x1000) != 0; // bit 13: 텍스트에 이어 바로 출력할지 여부 / bit 13: output immediately after text let prefix = (value & 0x2000) != 0; FootnoteShapeAttributes { number_shape, page_position, numbering, superscript, prefix, } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/memo_shape.rs	crates/hwp-core/src/document/bodytext/memo_shape.rs	/// MemoShape 구조체 / MemoShape structure /// /// 구현 상태 / Implementation Status /// - 구현 완료 / Implementation complete /// - 스펙 문서에 상세 구조가 명시되어 있지 않음 / Spec document does not specify detailed structure /// - 테스트 파일(`noori.hwp`)에 MEMO_SHAPE 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain MEMO_SHAPE records /// /// 참고 / Note /// DocInfo의 MEMO_SHAPE는 22바이트로 정의되어 있지만, BodyText의 MEMO_SHAPE는 가변 길이입니다. /// DocInfo's MEMO_SHAPE is defined as 22 bytes, but BodyText's MEMO_SHAPE is variable length. use crate::error::HwpError; use serde::{Deserialize, Serialize}; /// 메모 모양 / Memo shape #[derive(Debug, Clone, Serialize, Deserialize)] pub struct MemoShape { /// Raw 데이터 / Raw data /// 스펙 문서에 상세 구조가 명시되어 있지 않으므로 raw 데이터로 저장합니다. /// Raw data is stored because the spec document does not specify detailed structure. #[serde(skip_serializing_if = "Vec::is_empty")] pub raw_data: Vec<u8>, } impl MemoShape { /// MemoShape을 바이트 배열에서 파싱합니다. / Parse MemoShape from byte array. /// /// # Arguments /// * `data` - MemoShape 데이터 / MemoShape data /// /// # Returns /// 파싱된 MemoShape 구조체 / Parsed MemoShape structure /// /// # Note /// 스펙 문서 표 57에는 "메모 모양"으로만 언급되어 있고 상세 구조가 명시되어 있지 않습니다. /// 레거시 코드(hwp.js)도 raw 데이터로만 저장하고 있습니다. /// Spec document Table 57 only mentions "Memo shape" and does not specify detailed structure. /// Legacy code (hwp.js) also stores only raw data. /// /// 테스트 상태 / Testing Status /// 현재 테스트 파일(`noori.hwp`)에 MEMO_SHAPE 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 MEMO_SHAPE 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain MEMO_SHAPE records, so it has not been verified with actual files. /// If an actual HWP file contains MEMO_SHAPE records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { Ok(MemoShape { raw_data: data.to_vec(), }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/table.rs	crates/hwp-core/src/document/bodytext/table.rs	/// Table 구조체 / Table structure /// /// 스펙 문서 매핑: 표 74 - 표 개체 / Spec mapping: Table 74 - Table object use crate::error::HwpError; use crate::types::{HWPUNIT, HWPUNIT16, UINT16, UINT32}; use serde::{Deserialize, Serialize}; use super::list_header::ListHeader; /// 표 개체 / Table object #[derive(Debug, Clone, Serialize, Deserialize)] pub struct Table { /// 표 개체 속성 (표 75 참조) / Table object attributes (see Table 75) pub attributes: TableAttributes, /// 셀 리스트 (표 79 참조) / Cell list (see Table 79) pub cells: Vec<TableCell>, } /// 표 개체 속성 (표 75) / Table object attributes (Table 75) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct TableAttributes { /// 속성 (표 76 참조) / Attribute (see Table 76) pub attribute: TableAttribute, /// 행 개수 / Row count pub row_count: UINT16, /// 열 개수 / Column count pub col_count: UINT16, /// 셀 간격 / Cell spacing pub cell_spacing: HWPUNIT16, /// 안쪽 여백 정보 (표 77 참조) / Padding information (see Table 77) pub padding: TablePadding, /// 행 크기 리스트 / Row size list pub row_sizes: Vec<HWPUNIT16>, /// 테두리 채우기 ID / Border fill ID pub border_fill_id: UINT16, /// 영역 속성 리스트 (5.0.1.0 이상) / Zone attributes list (5.0.1.0 and above) pub zones: Vec<TableZone>, } /// 표 속성의 속성 (표 76) / Table attribute properties (Table 76) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct TableAttribute { /// 쪽 경계에서 나눔 / Page break behavior pub page_break: PageBreakBehavior, /// 제목 줄 자동 반복 여부 / Header row auto repeat pub header_row_repeat: bool, } /// 쪽 경계에서 나눔 / Page break behavior #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum PageBreakBehavior { /// 나누지 않음 / No break NoBreak, /// 셀 단위로 나눔 / Break by cell BreakByCell, /// 나누지 않음 (다른 값) / No break (other value) NoBreakOther, } /// 안쪽 여백 정보 (표 77) / Padding information (Table 77) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct TablePadding { /// 왼쪽 여백 / Left padding pub left: HWPUNIT16, /// 오른쪽 여백 / Right padding pub right: HWPUNIT16, /// 위쪽 여백 / Top padding pub top: HWPUNIT16, /// 아래쪽 여백 / Bottom padding pub bottom: HWPUNIT16, } /// 영역 속성 (표 78) / Zone attributes (Table 78) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct TableZone { /// 시작 열 주소 / Start column address pub start_col: UINT16, /// 시작 행 주소 / Start row address pub start_row: UINT16, /// 끝 열 주소 / End column address pub end_col: UINT16, /// 끝 행 주소 / End row address pub end_row: UINT16, /// 테두리 채우기 ID / Border fill ID pub border_fill_id: UINT16, } /// 셀 리스트 (표 79) / Cell list (Table 79) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct TableCell { /// 문단 리스트 헤더 (표 65 참조) / Paragraph list header (see Table 65) pub list_header: ListHeader, /// 셀 속성 (표 80 참조) / Cell attributes (see Table 80) pub cell_attributes: CellAttributes, /// 셀 내부의 문단들 (레벨 3) / Paragraphs inside cell (level 3) #[serde(skip_serializing_if = "Vec::is_empty", default)] pub paragraphs: Vec<super::Paragraph>, } /// 셀 속성 (표 80) / Cell attributes (Table 80) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct CellAttributes { /// 열 주소 / Column address pub col_address: UINT16, /// 행 주소 / Row address pub row_address: UINT16, /// 열 병합 개수 / Column merge count pub col_span: UINT16, /// 행 병합 개수 / Row merge count pub row_span: UINT16, /// 폭 / Width pub width: HWPUNIT, /// 높이 / Height pub height: HWPUNIT, /// 왼쪽 여백 / Left margin pub left_margin: HWPUNIT16, /// 오른쪽 여백 / Right margin pub right_margin: HWPUNIT16, /// 위쪽 여백 / Top margin pub top_margin: HWPUNIT16, /// 아래쪽 여백 / Bottom margin pub bottom_margin: HWPUNIT16, /// 테두리/배경 아이디 / Border fill ID pub border_fill_id: UINT16, } impl Table { /// Table을 바이트 배열에서 파싱합니다. / Parse Table from byte array. /// /// # Arguments /// * `data` - Table 데이터 (개체 공통 속성 포함) / Table data (including object common properties) /// * `version` - 파일 버전 / File version /// /// # Returns /// 파싱된 Table 구조체 / Parsed Table structure pub fn parse(data: &[u8], version: u32) -> Result<Self, HwpError> { if data.is_empty() { return Err(HwpError::InsufficientData { field: "Table data".to_string(), expected: 1, actual: 0, }); } let mut offset = 0; // 레거시 코드를 보면 HWPTAG_TABLE은 개체 공통 속성을 건너뛰고 표 개체 속성부터 시작 // According to legacy code, HWPTAG_TABLE skips object common properties and starts from table attributes // 표 개체 속성 파싱 (표 75) / Parse table object attributes (Table 75) let attributes = parse_table_attributes(data, &mut offset, version)?; // IMPORTANT: // HWP 5.x 실데이터에서는 "표 셀"의 실제 메타(행/열, 폭/높이, 마진, borderFill 등)와 // 셀 내부 문단은 대부분 HWPTAG_LIST_HEADER(테이블 셀 리스트) 트리로 제공됩니다. // // legacy hwpjs / pyhwp 구현도 이 LIST_HEADER 기반을 단일 소스로 취급하는 방식이며, // HWPTAG_TABLE payload(표 79/80)를 추정 파싱하면 오프셋 불일치로 "가짜 셀"이 하나 더 생기는 // 케이스(table-caption 등)가 있습니다. // // 따라서 여기서는 HWPTAG_TABLE payload에서 셀 리스트를 만들지 않고, // 트리 결합 단계(document/bodytext/mod.rs)에서 LIST_HEADER 기반으로 table.cells를 구성합니다. let cells = Vec::new(); Ok(Table { attributes, cells }) } } /// 표 개체 속성 파싱 (표 75) / Parse table object attributes (Table 75) fn parse_table_attributes( data: &[u8], offset: &mut usize, version: u32, ) -> Result<TableAttributes, HwpError> { // 최소 22바이트 필요 (기본 필드) / Need at least 22 bytes (basic fields) if data.len() < offset + 22 { return Err(HwpError::insufficient_data( "Table attributes", 22, data.len() - offset, )); } // UINT32 속성 (표 76 참조) / UINT32 attribute (see Table 76) let attribute_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // UINT16 RowCount / UINT16 RowCount let row_count_raw = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT16 nCols / UINT16 nCols let col_count_raw = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // row_count와 col_count는 UINT16이므로 최대 65535까지 가능 / row_count and col_count are UINT16, so max 65535 // JSON에서는 정상적으로 파싱되므로 파싱 자체는 문제없음 / Parsing is fine since JSON shows normal values // 실제 문제는 row_sizes 메모리 손상이므로, row_count/col_count는 그대로 사용 / Actual issue is row_sizes memory corruption, so use row_count/col_count as is let row_count = row_count_raw; let col_count = col_count_raw; // HWPUNIT16 CellSpacing / HWPUNIT16 CellSpacing let cell_spacing = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // BYTE stream 8 안쪽 여백 정보 (표 77 참조) / BYTE stream 8 padding information (see Table 77) let padding = TablePadding { left: HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]), right: HWPUNIT16::from_le_bytes([data[offset + 2], data[offset + 3]]), top: HWPUNIT16::from_le_bytes([data[offset + 4], data[offset + 5]]), bottom: HWPUNIT16::from_le_bytes([data[offset + 6], data[offset + 7]]), }; offset += 8; // BYTE stream 2×row Row Size / BYTE stream 2×row Row Size // row_count가 이미 유효성 검사를 거쳤으므로 안전하게 파싱 / row_count is already validated, so safe to parse let mut row_sizes = Vec::new(); for _ in 0..row_count { if offset + 2 > data.len() { // 데이터가 부족하면 중단하고 지금까지 파싱한 것만 사용 / Stop if insufficient data and use what we've parsed so far break; } row_sizes.push(HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]])); offset += 2; } // row_sizes가 row_count와 일치하지 않으면 빈 Vec로 초기화 / Initialize as empty Vec if row_sizes doesn't match row_count // 메모리 손상 방지를 위해 유효성 검사 / Validate to prevent memory corruption if row_sizes.len() != row_count as usize { row_sizes = Vec::new(); } // UINT16 Border Fill ID / UINT16 Border Fill ID let border_fill_id = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT16 Valid Zone Info Size (5.0.1.0 이상) / UINT16 Valid Zone Info Size (5.0.1.0 and above) let mut zones = Vec::new(); if version >= 5010 { if offset + 2 > data.len() { return Err(HwpError::insufficient_data( "valid zone info size", 2, data.len() - offset, )); } let valid_zone_info_size = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // BYTE stream 10×zone 영역 속성 (표 78 참조) / BYTE stream 10×zone zone attributes (see Table 78) let zone_count = valid_zone_info_size as usize / 10; for _ in 0..zone_count { if offset + 10 > data.len() { return Err(HwpError::insufficient_data( "zone attributes", 10, data.len() - offset, )); } zones.push(TableZone { start_col: UINT16::from_le_bytes([data[offset], data[offset + 1]]), start_row: UINT16::from_le_bytes([data[offset + 2], data[offset + 3]]), end_col: UINT16::from_le_bytes([data[offset + 4], data[offset + 5]]), end_row: UINT16::from_le_bytes([data[offset + 6], data[offset + 7]]), border_fill_id: UINT16::from_le_bytes([data[offset + 8], data[offset + 9]]), }); offset += 10; } } // 속성 파싱 (표 76) / Parse attribute (Table 76) let attribute = parse_table_attribute(attribute_value); // row_count=0이거나 row_sizes가 row_count와 일치하지 않으면 빈 Vec로 초기화 / Initialize as empty Vec if row_count=0 or row_sizes doesn't match row_count // Vec의 메타데이터 손상 방지를 위해 명시적으로 빈 Vec 사용 / Use explicit empty Vec to prevent Vec metadata corruption let final_row_sizes = if row_count == 0 \|\| row_sizes.len() != row_count as usize { Vec::new() } else { row_sizes }; let result = TableAttributes { attribute, row_count, col_count, cell_spacing, padding, row_sizes: final_row_sizes, // row_count=0이거나 row_sizes가 비어있거나 비정상적으로 크면 빈 Vec 사용 / Use empty Vec when row_count=0 or row_sizes is empty/abnormal border_fill_id, zones, }; Ok(result) } /// 표 속성의 속성 파싱 (표 76) / Parse table attribute properties (Table 76) fn parse_table_attribute(value: UINT32) -> TableAttribute { // bit 0-1: 쪽 경계에서 나눔 / bit 0-1: page break behavior let page_break = match value & 0x03 { 0 => PageBreakBehavior::NoBreak, 1 => PageBreakBehavior::BreakByCell, 2 => PageBreakBehavior::NoBreakOther, _ => PageBreakBehavior::NoBreak, }; // bit 2: 제목 줄 자동 반복 여부 / bit 2: header row auto repeat let header_row_repeat = (value & 0x04) != 0; TableAttribute { page_break, header_row_repeat, } } /// 셀 리스트 파싱 (표 79) / Parse cell list (Table 79) #[allow(dead_code)] fn parse_cell_list( data: &[u8], row_count: UINT16, col_count: UINT16, row_sizes: &[HWPUNIT16], // 각 행의 실제 셀 개수 ) -> Result<Vec<TableCell>, HwpError> { let mut cells = Vec::new(); let mut offset = 0; // 셀 개수 산정: // - 스펙/실데이터에서 row_sizes는 "각 행의 실제 셀 개수"로 사용됩니다. // - row_sizes가 유효하면(합>0) 그대로 사용하고, 없으면 row_countcol_count로 폴백합니다. let total_cells_from_row_sizes: usize = row_sizes.iter().map(\|&size\| size as usize).sum(); let total_cells = if total_cells_from_row_sizes > 0 { total_cells_from_row_sizes } else { row_count as usize col_count as usize }; // ListHeader(표 65)는 문서에 6바이트로 되어 있으나, 실제 파일에서는 // [paragraph_count:2][unknown1:2][attribute:4]의 8바이트 형태가 존재합니다. // // TableCell에서는 ListHeader 바로 뒤에 CellAttributes(표 80, 26바이트)가 이어지므로, // "6바이트/8바이트" 중 어떤 레이아웃인지 실제 바이트를 보고 판별해야 오프셋이 틀어지지 않습니다. fn parse_cell_attributes_at(data: &[u8], offset: usize) -> Option<CellAttributes> { if offset + 26 > data.len() { return None; } Some(CellAttributes { col_address: UINT16::from_le_bytes([data[offset], data[offset + 1]]), row_address: UINT16::from_le_bytes([data[offset + 2], data[offset + 3]]), col_span: UINT16::from_le_bytes([data[offset + 4], data[offset + 5]]), row_span: UINT16::from_le_bytes([data[offset + 6], data[offset + 7]]), width: HWPUNIT::from(UINT32::from_le_bytes([ data[offset + 8], data[offset + 9], data[offset + 10], data[offset + 11], ])), height: HWPUNIT::from(UINT32::from_le_bytes([ data[offset + 12], data[offset + 13], data[offset + 14], data[offset + 15], ])), left_margin: HWPUNIT16::from_le_bytes([data[offset + 16], data[offset + 17]]), right_margin: HWPUNIT16::from_le_bytes([data[offset + 18], data[offset + 19]]), top_margin: HWPUNIT16::from_le_bytes([data[offset + 20], data[offset + 21]]), bottom_margin: HWPUNIT16::from_le_bytes([data[offset + 22], data[offset + 23]]), border_fill_id: UINT16::from_le_bytes([data[offset + 24], data[offset + 25]]), }) } fn is_plausible_cell_attrs( attrs: &CellAttributes, row_count: UINT16, col_count: UINT16, ) -> bool { // row/col은 테이블 범위 내여야 함 if attrs.row_address >= row_count \|\| attrs.col_address >= col_count { return false; } // 폭/높이는 0이 아닌 것이 일반적 (0이면 오프셋 오판 가능성이 큼) if attrs.width.0 == 0 \|\| attrs.height.0 == 0 { return false; } true } for _ in 0..total_cells { if offset >= data.len() { break; // 셀 데이터가 부족할 수 있음 / Cell data may be insufficient } // 1) ListHeader 크기(6/8) 판별 // - 우선 8바이트로 가정한 뒤, 그 다음 26바이트를 CellAttributes로 해석했을 때 값이 그럴듯하면 8 // - 아니면 6바이트로 시도 // - 둘 다 그럴듯하지 않으면(데이터 손상 등) 8을 기본으로 둠 (기존 로직과 호환) let header_len = { let mut chosen = 8usize; let try8 = parse_cell_attributes_at(data, offset + 8) .filter(\|a\| is_plausible_cell_attrs(a, row_count, col_count)); let try6 = parse_cell_attributes_at(data, offset + 6) .filter(\|a\| is_plausible_cell_attrs(a, row_count, col_count)); if try8.is_some() { chosen = 8; } else if try6.is_some() { chosen = 6; } chosen }; // 2) ListHeader 파싱 (확정된 길이만큼) if offset + header_len > data.len() { break; } let list_header = ListHeader::parse(&data[offset..offset + header_len]).map_err(\|e\| HwpError::from(e))?; offset += header_len; // 셀 속성 파싱 (표 80 참조) / Parse cell attributes (see Table 80) // 표 80: 전체 길이 26바이트 // UINT16(2) + UINT16(2) + UINT16(2) + UINT16(2) + HWPUNIT(4) + HWPUNIT(4) + HWPUNIT16[4](8) + UINT16(2) = 26 if offset + 26 > data.len() { return Err(HwpError::insufficient_data( "cell attributes", 26, data.len() - offset, )); } let cell_attributes = parse_cell_attributes_at(data, offset).ok_or_else(\|\| { HwpError::insufficient_data("cell attributes", 26, data.len().saturating_sub(offset)) })?; offset += 26; cells.push(TableCell { list_header, cell_attributes, paragraphs: Vec::new(), // 트리 구조에서 나중에 채워짐 / Will be filled from tree structure later }); } Ok(cells) }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/range_tag.rs	crates/hwp-core/src/document/bodytext/range_tag.rs	/// RangeTagInfo 구조체 / RangeTagInfo structure /// /// 스펙 문서 매핑: 표 63 - 문단의 영역 태그 / Spec mapping: Table 63 - Paragraph range tag /// 각 항목: 12바이트 use crate::error::HwpError; use crate::types::{UINT32, UINT8}; use serde::{Deserialize, Serialize}; /// 영역 태그 정보 / Range tag information #[derive(Debug, Clone, Serialize, Deserialize)] pub struct RangeTagInfo { /// 영역 시작 위치 / Range start position pub start: UINT32, /// 영역 끝 위치 / Range end position pub end: UINT32, /// 태그 종류 (상위 8비트) / Tag type (upper 8 bits) pub tag_type: UINT8, /// 태그 데이터 (하위 24비트) / Tag data (lower 24 bits) pub tag_data: UINT32, } impl RangeTagInfo { /// RangeTagInfo를 바이트 배열에서 파싱합니다. / Parse RangeTagInfo from byte array. /// /// # Arguments /// * `data` - 최소 12바이트의 데이터 / At least 12 bytes of data /// /// # Returns /// 파싱된 RangeTagInfo 구조체 / Parsed RangeTagInfo structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 12 { return Err(HwpError::insufficient_data("RangeTagInfo", 12, data.len())); } // UINT32 영역 시작 / UINT32 range start let start = UINT32::from_le_bytes([data[0], data[1], data[2], data[3]]); // UINT32 영역 끝 / UINT32 range end let end = UINT32::from_le_bytes([data[4], data[5], data[6], data[7]]); // UINT32 태그(종류 + 데이터) / UINT32 tag (type + data) // 상위 8비트가 종류, 하위 24비트가 데이터 / Upper 8 bits are type, lower 24 bits are data let tag_value = UINT32::from_le_bytes([data[8], data[9], data[10], data[11]]); let tag_type = ((tag_value >> 24) & 0xFF) as UINT8; let tag_data = tag_value & 0x00FFFFFF; Ok(RangeTagInfo { start, end, tag_type, tag_data, }) } } /// 문단의 영역 태그 리스트 / Paragraph range tag list #[derive(Debug, Clone, Default, Serialize, Deserialize)] pub struct ParaRangeTag { /// 영역 태그 정보 리스트 / Range tag information list pub tags: Vec<RangeTagInfo>, } impl ParaRangeTag { /// ParaRangeTag를 바이트 배열에서 파싱합니다. / Parse ParaRangeTag from byte array. /// /// # Arguments /// * `data` - 영역 태그 데이터 (12×n 바이트) / Range tag data (12×n bytes) /// /// # Returns /// 파싱된 ParaRangeTag 구조체 / Parsed ParaRangeTag structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() % 12 != 0 { return Err(HwpError::UnexpectedValue { field: "ParaRangeTag data length".to_string(), expected: "multiple of 12".to_string(), found: format!("{} bytes", data.len()), }); } let count = data.len() / 12; let mut tags = Vec::with_capacity(count); for i in 0..count { let offset = i * 12; let tag_data = &data[offset..offset + 12]; let tag_info = RangeTagInfo::parse(tag_data) .map_err(\|e\| HwpError::from(e))?; tags.push(tag_info); } Ok(ParaRangeTag { tags }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/page_border_fill.rs	crates/hwp-core/src/document/bodytext/page_border_fill.rs	/// PageBorderFill 구조체 / PageBorderFill structure /// /// 스펙 문서 매핑: 표 135 - 쪽 테두리/배경 / Spec mapping: Table 135 - Page border/fill use crate::error::HwpError; use crate::types::{HWPUNIT16, UINT16, UINT32}; use serde::{Deserialize, Serialize}; /// 쪽 테두리/배경 / Page border/fill #[derive(Debug, Clone, Serialize, Deserialize)] pub struct PageBorderFill { /// 속성 / Attributes pub attributes: PageBorderFillAttributes, /// 테두리/배경 위치 왼쪽 간격 / Left spacing pub left_spacing: HWPUNIT16, /// 테두리/배경 위치 오른쪽 간격 / Right spacing pub right_spacing: HWPUNIT16, /// 테두리/배경 위치 위쪽 간격 / Top spacing pub top_spacing: HWPUNIT16, /// 테두리/배경 위치 아래쪽 간격 / Bottom spacing pub bottom_spacing: HWPUNIT16, /// 테두리/배경 ID / Border/fill ID pub border_fill_id: UINT16, } /// 쪽 테두리/배경 속성 / Page border/fill attributes #[derive(Debug, Clone, Serialize, Deserialize)] pub struct PageBorderFillAttributes { /// 위치 기준 / Position reference pub position_reference: PositionReference, /// 머리말 포함 여부 / Include header pub include_header: bool, /// 꼬리말 포함 여부 / Include footer pub include_footer: bool, /// 채울 영역 / Fill area pub fill_area: FillArea, } /// 위치 기준 / Position reference #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum PositionReference { /// 본문 기준 / Body text reference BodyText, /// 종이 기준 / Paper reference Paper, } /// 채울 영역 / Fill area #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum FillArea { /// 종이 / Paper Paper, /// 쪽 / Page Page, /// 테두리 / Border Border, } impl PageBorderFill { /// PageBorderFill를 바이트 배열에서 파싱합니다. / Parse PageBorderFill from byte array. /// /// # Arguments /// * `data` - 최소 12바이트의 데이터 / At least 12 bytes of data /// /// # Returns /// 파싱된 PageBorderFill 구조체 / Parsed PageBorderFill structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 12 { return Err(HwpError::insufficient_data("PageBorderFill", 12, data.len())); } let mut offset = 0; // UINT 속성 (표 136 참조) / UINT attributes (see Table 136) let attribute_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 속성 파싱 (표 136) / Parse attributes (Table 136) let attributes = parse_page_border_fill_attributes(attribute_value); // HWPUNIT16 테두리/배경 위치 왼쪽 간격 / HWPUNIT16 left spacing let left_spacing = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // HWPUNIT16 테두리/배경 위치 오른쪽 간격 / HWPUNIT16 right spacing let right_spacing = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // HWPUNIT16 테두리/배경 위치 위쪽 간격 / HWPUNIT16 top spacing let top_spacing = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // HWPUNIT16 테두리/배경 위치 아래쪽 간격 / HWPUNIT16 bottom spacing let bottom_spacing = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT16 테두리/배경 ID / UINT16 border/fill ID let border_fill_id = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; Ok(PageBorderFill { attributes, left_spacing, right_spacing, top_spacing, bottom_spacing, border_fill_id, }) } } /// 쪽 테두리/배경 속성 파싱 (표 136) / Parse page border/fill attributes (Table 136) fn parse_page_border_fill_attributes(value: UINT32) -> PageBorderFillAttributes { // bit 0: 위치 기준 / bit 0: position reference // 0: 본문 기준 / 0: body text reference // 1: 종이 기준 / 1: paper reference let position_reference = if (value & 0x01) == 0 { PositionReference::BodyText } else { PositionReference::Paper }; // bit 1: 머리말 포함 여부 / bit 1: include header let include_header = (value & 0x02) != 0; // bit 2: 꼬리말 포함 여부 / bit 2: include footer let include_footer = (value & 0x04) != 0; // bit 3-4: 채울 영역 / bit 3-4: fill area // 0: 종이 / 0: paper // 1: 쪽 / 1: page // 2: 테두리 / 2: border let fill_area = match (value >> 3) & 0x03 { 0 => FillArea::Paper, 1 => FillArea::Page, 2 => FillArea::Border, _ => FillArea::Paper, // 기본값 / default }; PageBorderFillAttributes { position_reference, include_header, include_footer, fill_area, } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/video_data.rs	crates/hwp-core/src/document/bodytext/video_data.rs	/// VideoData 구조체 / VideoData structure /// /// 스펙 문서 매핑: 표 123 - 동영상 개체 속성 / Spec mapping: Table 123 - Video object attributes /// /// 구현 상태 / Implementation Status /// - 구현 완료 / Implementation complete /// - 테스트 파일(`noori.hwp`)에 VIDEO_DATA 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain VIDEO_DATA records use crate::error::HwpError; use crate::types::{decode_utf16le, INT32, UINT16}; use serde::{Deserialize, Serialize}; /// 동영상 개체 / Video object #[derive(Debug, Clone, Serialize, Deserialize)] pub struct VideoData { /// 동영상 타입 (표 124 참조) / Video type (see Table 124) /// - 0: 로컬 동영상 / Local video /// - 1: 웹 동영상 / Web video pub video_type: INT32, /// 동영상 타입에 따른 속성 / Attributes based on video type pub video_attributes: VideoAttributes, } /// 동영상 속성 / Video attributes #[derive(Debug, Clone, Serialize, Deserialize)] #[serde(tag = "type", rename_all = "snake_case")] pub enum VideoAttributes { /// 로컬 동영상 속성 (표 125 참조) / Local video attributes (see Table 125) Local { /// 비디오 파일이 사용하는 스토리지의 BinData ID / BinData ID of storage used by video file video_bindata_id: UINT16, /// 썸네일 파일이 사용하는 스토리지의 BinData ID / BinData ID of storage used by thumbnail file thumbnail_bindata_id: UINT16, }, /// 웹 동영상 속성 (표 126 참조) / Web video attributes (see Table 126) Web { /// 웹 태그 / Web tag web_tag: String, /// 썸네일 파일이 사용하는 스토리지의 BinData ID / BinData ID of storage used by thumbnail file thumbnail_bindata_id: UINT16, }, } impl VideoData { /// VideoData를 바이트 배열에서 파싱합니다. / Parse VideoData from byte array. /// /// # Arguments /// * `data` - VideoData 데이터 (동영상 개체 속성 부분만) / VideoData data (video object attributes only) /// /// # Returns /// 파싱된 VideoData 구조체 / Parsed VideoData structure /// /// # Note /// 스펙 문서 표 122에 따르면 VIDEO_DATA는 다음 구조를 가집니다: /// - 개체 공통 속성(표 68 참조) - 가변 길이 /// - 동영상 개체 속성(표 123 참조) - 가변 길이 (4 + n 바이트) /// /// 레거시 코드(hwp.js)는 동영상 개체 속성을 파싱하지 않고 있습니다. /// According to spec Table 122, VIDEO_DATA has the following structure: /// - Object common properties (Table 68) - variable length /// - Video object attributes (Table 123) - variable length (4 + n bytes) /// /// Legacy code (hwp.js) does not parse video object attributes. /// /// 테스트 상태 / Testing Status /// 현재 테스트 파일(`noori.hwp`)에 VIDEO_DATA 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 VIDEO_DATA 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain VIDEO_DATA records, so it has not been verified with actual files. /// If an actual HWP file contains VIDEO_DATA records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // 최소 4바이트 필요 (동영상 타입) / Need at least 4 bytes (video type) if data.len() < 4 { return Err(HwpError::insufficient_data("VideoData", 4, data.len())); } let mut offset = 0; // 표 123: 동영상 타입 (INT32, 4바이트) / Table 123: Video type (INT32, 4 bytes) let video_type = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 123: 동영상 타입에 따른 속성 파싱 / Table 123: Parse attributes based on video type let video_attributes = match video_type { 0 => { // 로컬 동영상 속성 (표 125) / Local video attributes (Table 125) if data.len() < offset + 4 { return Err(HwpError::insufficient_data( "VideoData local video attributes", 4, data.len() - offset, )); } let video_bindata_id = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let thumbnail_bindata_id = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; VideoAttributes::Local { video_bindata_id, thumbnail_bindata_id, } } 1 => { // 웹 동영상 속성 (표 126) / Web video attributes (Table 126) // 웹 태그는 가변 길이이므로, 나머지 데이터에서 썸네일 BinData ID(2바이트)를 제외한 부분이 웹 태그 // Web tag is variable length, so remaining data minus thumbnail BinData ID (2 bytes) is web tag if data.len() < offset + 2 { return Err(HwpError::insufficient_data( "VideoData web video attributes", 2, data.len() - offset, )); } // 웹 태그 길이 계산: 전체 길이 - offset - 썸네일 BinData ID(2바이트) // Calculate web tag length: total length - offset - thumbnail BinData ID (2 bytes) let web_tag_length = data.len().saturating_sub(offset + 2); if web_tag_length == 0 { return Err(HwpError::UnexpectedValue { field: "VideoData web tag length".to_string(), expected: "positive number".to_string(), found: "0".to_string(), }); } let web_tag_bytes = &data[offset..offset + web_tag_length]; let web_tag = decode_utf16le(web_tag_bytes) .map_err(\|e\| HwpError::EncodingError { reason: format!("Failed to decode web tag: {}", e), })?; offset += web_tag_length; let thumbnail_bindata_id = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; VideoAttributes::Web { web_tag, thumbnail_bindata_id, } } _ => { return Err(HwpError::UnexpectedValue { field: "VideoData video_type".to_string(), expected: "0 or 1".to_string(), found: video_type.to_string(), }); } }; Ok(VideoData { video_type, video_attributes, }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/mod.rs	crates/hwp-core/src/document/bodytext/mod.rs	mod char_shape; /// BodyText parsing module /// /// This module handles parsing of HWP BodyText storage. /// /// 스펙 문서 매핑: 표 2 - 본문 (BodyText 스토리지) pub mod constants; pub use constants::HwpTag; pub mod control_char; pub use control_char::{ControlChar, ControlCharPosition}; pub mod chart_data; pub mod ctrl_data; pub mod ctrl_header; pub mod eqedit; pub mod footnote_shape; pub mod form_object; pub mod line_seg; pub mod list_header; pub mod memo_list; pub mod memo_shape; pub mod page_border_fill; pub mod page_def; pub mod para_header; pub mod range_tag; pub mod record_tree; pub mod shape_component; pub mod table; pub mod video_data; pub use char_shape::{CharShapeInfo, ParaCharShape}; pub use chart_data::ChartData; pub use ctrl_data::CtrlData; pub use ctrl_header::{CtrlHeader, CtrlHeaderData, CtrlId, Margin, PageNumberPosition}; pub use eqedit::EqEdit; pub use footnote_shape::{FootnoteShape, NumberShape}; pub use form_object::FormObject; pub use line_seg::{LineSegmentInfo, ParaLineSeg}; pub use list_header::ListHeader; pub use memo_list::MemoList; pub use memo_shape::MemoShape; pub use page_border_fill::PageBorderFill; pub use page_def::{PageDef, PaperDirection}; pub use para_header::{ColumnDivideType, ControlMask, ParaHeader}; pub use range_tag::{ParaRangeTag, RangeTagInfo}; pub use shape_component::ShapeComponent; pub use shape_component::ShapeComponentArc; pub use shape_component::ShapeComponentContainer; pub use shape_component::ShapeComponentCurve; pub use shape_component::ShapeComponentEllipse; pub use shape_component::ShapeComponentLine; pub use shape_component::ShapeComponentOle; pub use shape_component::ShapeComponentPicture; pub use shape_component::ShapeComponentPolygon; pub use shape_component::ShapeComponentRectangle; pub use shape_component::ShapeComponentTextArt; pub use shape_component::ShapeComponentUnknown; pub use table::{Table, TableCell}; pub use video_data::VideoData; use crate::cfb::CfbParser; use crate::decompress::decompress_deflate; use crate::document::bodytext::ctrl_header::Caption; use crate::document::fileheader::FileHeader; use crate::error::HwpError; use crate::types::{decode_utf16le, RecordHeader, WORD}; use cfb::CompoundFile; use record_tree::RecordTreeNode; use serde::{Deserialize, Serialize}; use std::io::Cursor; /// Body text structure #[derive(Debug, Clone, Default, Serialize, Deserialize)] pub struct BodyText { /// Sections (Section0, Section1, etc.) pub sections: Vec<Section>, } /// Section structure #[derive(Debug, Clone, Default, Serialize, Deserialize)] pub struct Section { /// Section index pub index: WORD, /// Paragraphs in this section pub paragraphs: Vec<Paragraph>, } /// Paragraph structure #[derive(Debug, Clone, Default, Serialize, Deserialize)] pub struct Paragraph { /// Paragraph header (level 0 record) pub para_header: ParaHeader, /// Paragraph records (level 1 records) pub records: Vec<ParagraphRecord>, } /// Paragraph record (level 1 records) #[derive(Debug, Clone, Serialize, Deserialize)] #[serde(tag = "type", rename_all = "snake_case")] pub enum ParagraphRecord { /// 문단의 텍스트 / Paragraph text ParaText { /// 텍스트 내용 (UTF-16LE) / Text content (UTF-16LE) text: String, /// 텍스트/컨트롤 토큰 시퀀스 (표/개체 등 위치를 보존하기 위한 구조) / Text/control token sequence #[serde(skip_serializing_if = "Vec::is_empty", default)] runs: Vec<ParaTextRun>, /// 제어 문자 위치 정보 / Control character positions /// 제어 문자가 없어도 빈 배열로 표시되어 JSON에 포함됩니다 / Empty array is included in JSON even if no control characters #[serde(default)] control_char_positions: Vec<crate::document::bodytext::control_char::ControlCharPosition>, /// INLINE 제어 문자 파라미터 정보 (문자 인덱스, 파라미터) / INLINE control character parameter information (char index, parameter) /// INLINE 타입 제어 문자(FIELD_END, TITLE_MARK, TAB 등)의 파라미터를 저장합니다. /// Stores parameters for INLINE type control characters (FIELD_END, TITLE_MARK, TAB, etc.). /// 스펙 문서에 파라미터 구조가 명시되지 않았으므로 바이트 배열로 저장됩니다. /// Parameter structure is not specified in spec document, so stored as byte array. #[serde(skip_serializing_if = "Vec::is_empty", default)] inline_control_params: Vec<( usize, crate::document::bodytext::control_char::InlineControlParam, )>, }, /// 문단의 글자 모양 / Paragraph character shape ParaCharShape { /// 글자 모양 정보 리스트 / Character shape information list shapes: Vec<CharShapeInfo>, }, /// 문단의 레이아웃 / Paragraph line segment ParaLineSeg { /// 줄 세그먼트 정보 리스트 / Line segment information list segments: Vec<LineSegmentInfo>, }, /// 문단의 영역 태그 / Paragraph range tag ParaRangeTag { /// 영역 태그 정보 리스트 / Range tag information list tags: Vec<RangeTagInfo>, }, /// 컨트롤 헤더 / Control header CtrlHeader { /// 컨트롤 헤더 정보 / Control header information #[serde(flatten)] header: CtrlHeader, /// 컨트롤 헤더의 자식 레코드 (레벨 2) / Child records of control header (level 2) /// 각주/미주, 머리말/꼬리말 등의 컨트롤 헤더 내부에 PARA_HEADER가 직접 올 수 있음 /// PARA_HEADER는 Paragraph로 변환되어 paragraphs에 저장됨 /// PARA_HEADER can appear directly inside control headers like footnotes/endnotes, headers/footers, etc. /// PARA_HEADER is converted to Paragraph and stored in paragraphs #[serde(skip_serializing_if = "Vec::is_empty", default)] children: Vec<ParagraphRecord>, /// 컨트롤 헤더 내부의 문단들 (레벨 2 이상의 PARA_HEADER) / Paragraphs inside control header (PARA_HEADER at level 2 or higher) /// 각주/미주, 머리말/꼬리말 등의 컨트롤 헤더 내부에 직접 나타나는 문단들 /// Paragraphs that appear directly inside control headers like footnotes/endnotes, headers/footers, etc. #[serde(skip_serializing_if = "Vec::is_empty", default)] paragraphs: Vec<Paragraph>, }, /// 문단 리스트 헤더 / Paragraph list header ListHeader { /// 문단 리스트 헤더 정보 / Paragraph list header information header: ListHeader, /// 리스트 헤더의 자식 문단들 (레벨 3, 예: 테이블 셀 내부 문단) / Child paragraphs of list header (level 3, e.g., paragraphs inside table cell) #[serde(skip_serializing_if = "Vec::is_empty", default)] paragraphs: Vec<Paragraph>, }, /// 표 개체 / Table object Table { /// 표 개체 정보 / Table object information table: Table, }, /// 용지 설정 / Page definition PageDef { /// 용지 설정 정보 / Page definition information page_def: PageDef, }, /// 각주/미주 모양 / Footnote/endnote shape FootnoteShape { /// 각주/미주 모양 정보 / Footnote/endnote shape information footnote_shape: FootnoteShape, }, /// 쪽 테두리/배경 / Page border/fill PageBorderFill { /// 쪽 테두리/배경 정보 / Page border/fill information page_border_fill: PageBorderFill, }, /// 개체 요소 / Shape component ShapeComponent { /// 개체 요소 정보 / Shape component information shape_component: ShapeComponent, /// 개체 요소의 자식 레코드 (레벨 3, 예: SHAPE_COMPONENT_PICTURE) / Child records of shape component (level 3, e.g., SHAPE_COMPONENT_PICTURE) #[serde(skip_serializing_if = "Vec::is_empty", default)] children: Vec<ParagraphRecord>, }, /// 직선 개체 / Line shape component ShapeComponentLine { /// 직선 개체 정보 / Line shape component information shape_component_line: ShapeComponentLine, }, /// 사각형 개체 / Rectangle shape component ShapeComponentRectangle { /// 사각형 개체 정보 / Rectangle shape component information shape_component_rectangle: ShapeComponentRectangle, }, /// 타원 개체 / Ellipse shape component ShapeComponentEllipse { /// 타원 개체 정보 / Ellipse shape component information shape_component_ellipse: ShapeComponentEllipse, }, /// 호 개체 / Arc shape component ShapeComponentArc { /// 호 개체 정보 / Arc shape component information shape_component_arc: ShapeComponentArc, }, /// 다각형 개체 / Polygon shape component ShapeComponentPolygon { /// 다각형 개체 정보 / Polygon shape component information shape_component_polygon: ShapeComponentPolygon, }, /// 곡선 개체 / Curve shape component ShapeComponentCurve { /// 곡선 개체 정보 / Curve shape component information shape_component_curve: ShapeComponentCurve, }, /// OLE 개체 / OLE shape component ShapeComponentOle { /// OLE 개체 정보 / OLE shape component information shape_component_ole: ShapeComponentOle, }, /// 그림 개체 / Picture shape component ShapeComponentPicture { /// 그림 개체 정보 / Picture shape component information shape_component_picture: ShapeComponentPicture, }, /// 묶음 개체 / Container shape component ShapeComponentContainer { /// 묶음 개체 정보 / Container shape component information shape_component_container: ShapeComponentContainer, }, /// 컨트롤 임의의 데이터 / Control arbitrary data CtrlData { /// 컨트롤 임의의 데이터 정보 / Control arbitrary data information ctrl_data: CtrlData, }, /// 수식 개체 / Equation editor object EqEdit { /// 수식 개체 정보 / Equation editor object information eqedit: EqEdit, }, /// 글맵시 개체 / Text art shape component ShapeComponentTextArt { /// 글맵시 개체 정보 / Text art shape component information shape_component_textart: ShapeComponentTextArt, }, /// 양식 개체 / Form object FormObject { /// 양식 개체 정보 / Form object information form_object: FormObject, }, /// 메모 모양 / Memo shape MemoShape { /// 메모 모양 정보 / Memo shape information memo_shape: MemoShape, }, /// 메모 리스트 헤더 / Memo list header MemoList { /// 메모 리스트 헤더 정보 / Memo list header information memo_list: MemoList, }, /// 차트 데이터 / Chart data ChartData { /// 차트 데이터 정보 / Chart data information chart_data: ChartData, }, /// 비디오 데이터 / Video data VideoData { /// 비디오 데이터 정보 / Video data information video_data: VideoData, }, /// Unknown 개체 / Unknown shape component ShapeComponentUnknown { /// Unknown 개체 정보 / Unknown shape component information shape_component_unknown: ShapeComponentUnknown, }, /// 기타 레코드 / Other records Other { /// Tag ID tag_id: WORD, /// Raw data data: Vec<u8>, }, } /// ParaText의 텍스트/컨트롤 토큰 / ParaText token (text or control) #[derive(Debug, Clone, Serialize, Deserialize)] #[serde(tag = "kind", rename_all = "snake_case")] pub enum ParaTextRun { /// 일반 텍스트 조각 / Plain text chunk Text { text: String }, /// 컨트롤 토큰(표/개체 등) / Control token (table/shape object etc.) Control { /// 원본 WCHAR 인덱스 위치 / Original WCHAR index position position: usize, /// 제어 문자 코드 (0-31) / Control character code (0-31) code: u8, /// 제어 문자 이름 / Control character name name: String, /// 원본에서 차지하는 WCHAR 길이 / Size in WCHAR units in original stream size_wchars: usize, /// 표시 텍스트(파생값) / Display text (derived value) /// /// - Source of truth가 아님: 원본 복원/Writer에서는 `runs`의 컨트롤 정보와 문서 설정으로 재계산해야 합니다. /// - 뷰어/프리뷰 용도로만 사용하며, 불일치 시 무시될 수 있습니다. #[serde(skip_serializing_if = "Option::is_none")] display_text: Option<String>, }, } impl Section { /// Section 데이터를 파싱하여 Paragraph 리스트로 변환합니다. / Parse section data into paragraph list. /// /// 트리 구조를 먼저 파싱한 후 재귀적으로 방문하여 구조화된 데이터로 변환합니다. /// First parses the tree structure, then recursively visits it to convert to structured data. /// /// # Arguments /// * `data` - Section의 원시 바이트 데이터 / Raw byte data of section /// * `version` - 파일 버전 / File version /// /// # Returns /// 파싱된 Paragraph 리스트 / Parsed paragraph list pub fn parse_data(data: &[u8], version: u32) -> Result<Vec<Paragraph>, HwpError> { // 먼저 레코드를 트리 구조로 파싱 / First parse records into tree structure let tree = RecordTreeNode::parse_tree(data).map_err(\|e\| HwpError::from(e))?; // 트리를 재귀적으로 방문하여 Paragraph 리스트로 변환 / Recursively visit tree to convert to Paragraph list let mut paragraphs = Vec::new(); for child in tree.children() { if child.tag_id() == HwpTag::PARA_HEADER { paragraphs.push( Self::parse_paragraph_from_tree(child, version, data) .map_err(\|e\| HwpError::from(e))?, ); } } Ok(paragraphs) } /// 트리 노드에서 Paragraph를 파싱합니다. / Parse Paragraph from tree node. /// /// 문단 헤더 노드와 그 자식들을 재귀적으로 처리합니다. /// Recursively processes paragraph header node and its children. fn parse_paragraph_from_tree( node: &RecordTreeNode, version: u32, original_data: &[u8], ) -> Result<Paragraph, HwpError> { Self::parse_paragraph_from_tree_internal(node, version, original_data, false) } /// 문단 헤더 노드와 그 자식들을 재귀적으로 처리합니다 (내부 함수). /// Recursively processes paragraph header node and its children (internal function). /// `is_inside_control_header`: 컨트롤 헤더 내부의 Paragraph인지 여부 /// `is_inside_control_header`: Whether this paragraph is inside a control header fn parse_paragraph_from_tree_internal( node: &RecordTreeNode, version: u32, original_data: &[u8], is_inside_control_header: bool, ) -> Result<Paragraph, HwpError> { if node.tag_id() != HwpTag::PARA_HEADER { return Err(HwpError::UnexpectedValue { field: "Paragraph tag".to_string(), expected: format!("{}", HwpTag::PARA_HEADER), found: format!("{}", node.tag_id()), }); } let para_header = ParaHeader::parse(node.data(), version).map_err(\|e\| HwpError::from(e))?; let mut records = Vec::new(); // 자식들을 처리 / Process children for child in node.children() { records.push( Self::parse_record_from_tree(child, version, original_data) .map_err(\|e\| HwpError::from(e))?, ); } // 컨트롤 헤더 내부의 머리말/꼬리말/각주/미주 문단인 경우에만 ParaText 레코드 제거 (중복 방지, hwplib 방식) // Remove ParaText records only from header/footer/footnote/endnote paragraphs inside control headers (avoid duplication, hwplib approach) // hwplib: 컨트롤 헤더 내부의 Paragraph의 ParaText에는 ExtendChar만 포함되고, 실제 텍스트는 ControlHeader 내부의 ParagraphList에만 있음 // hwplib: ParaText in paragraphs inside control headers only contains ExtendChar, actual text is only in ControlHeader's ParagraphList // 본문 Paragraph의 경우 ParaText에 참조 텍스트("각주참조" 등)가 포함되므로 제거하지 않음 // For body paragraphs, ParaText contains reference text ("각주참조" etc.), so don't remove it if is_inside_control_header { let is_control_paragraph = records.iter().any(\|record\| { if let ParagraphRecord::CtrlHeader { header, .. } = record { use crate::document::bodytext::CtrlId; header.ctrl_id.as_str() == CtrlId::HEADER \|\| header.ctrl_id.as_str() == CtrlId::FOOTER \|\| header.ctrl_id.as_str() == CtrlId::FOOTNOTE \|\| header.ctrl_id.as_str() == CtrlId::ENDNOTE } else { false } }); if is_control_paragraph { // ParaText 레코드만 필터링 (다른 레코드는 유지) // Filter out only ParaText records (keep other records) let before_count = records.len(); records.retain(\|record\| !matches!(record, ParagraphRecord::ParaText { .. })); let after_count = records.len(); if before_count != after_count { #[cfg(debug_assertions)] eprintln!("[DEBUG] Removed {} ParaText records from control paragraph (is_inside_control_header={})", before_count - after_count, is_inside_control_header); } } } else { // 본문 Paragraph의 경우 ParaText 확인 (디버그) // Check ParaText in body paragraph (debug) let para_text_count = records .iter() .filter(\|record\| matches!(record, ParagraphRecord::ParaText { .. })) .count(); if para_text_count > 0 { for record in &records { if let ParagraphRecord::ParaText { text, .. } = record { #[cfg(debug_assertions)] eprintln!("[DEBUG] Body paragraph ParaText: {}", text); } } } } Ok(Paragraph { para_header, records, }) } /// 트리 노드에서 ParagraphRecord를 파싱합니다. / Parse ParagraphRecord from tree node. /// /// 모든 레벨의 레코드를 재귀적으로 처리합니다. /// Recursively processes records at all levels. fn parse_record_from_tree( node: &RecordTreeNode, version: u32, original_data: &[u8], ) -> Result<ParagraphRecord, HwpError> { match node.tag_id() { HwpTag::PARA_TEXT => { let data = node.data(); // pyhwp처럼 제어 문자를 찾고 텍스트만 추출 / Find control characters and extract only text like pyhwp let mut control_char_positions = Vec::new(); let mut inline_control_params = Vec::new(); let mut cleaned_text = String::new(); let mut runs: Vec<ParaTextRun> = Vec::new(); let mut idx = 0; while idx < data.len() { // 제어 문자 찾기 (UTF-16LE 바이트 배열에서) / Find control character (in UTF-16LE byte array) let mut found_control = false; let mut control_code = 0u8; let mut control_size = 0usize; // 현재 위치에서 제어 문자 확인 (0-31 범위) / Check for control character at current position (range 0-31) if idx + 1 < data.len() { let code = data[idx] as u32; // 제어 문자는 UTF-16LE에서 하위 바이트가 0-31이고 상위 바이트가 0인 경우 / Control character is when lower byte is 0-31 and upper byte is 0 in UTF-16LE if code <= 31 && data[idx + 1] == 0 { control_code = code as u8; control_size = ControlChar::get_size_by_code(control_code) * 2; // WCHAR를 바이트로 변환 / Convert WCHAR to bytes found_control = true; } } if found_control { // 제어 문자 위치 저장 (문자 인덱스 기준) / Store control character position (based on character index) let char_idx = idx / 2; // UTF-16LE에서 문자 인덱스는 바이트 인덱스 / 2 / Character index in UTF-16LE is byte index / 2 let control_name = ControlChar::to_name(control_code); control_char_positions.push( crate::document::bodytext::control_char::ControlCharPosition { position: char_idx, code: control_code, name: control_name.clone(), }, ); runs.push(ParaTextRun::Control { position: char_idx, code: control_code, name: control_name, size_wchars: ControlChar::get_size_by_code(control_code), display_text: None, }); // INLINE 타입 제어 문자인 경우 파라미터 파싱 / Parse parameters for INLINE type control characters if ControlChar::get_size_by_code(control_code) == 8 && matches!( control_code, ControlChar::FIELD_END \| ControlChar::RESERVED_5_7_START..=ControlChar::RESERVED_5_7_END \| ControlChar::TITLE_MARK \| ControlChar::TAB \| ControlChar::RESERVED_19_20_START..=ControlChar::RESERVED_19_20_END ) { // 제어 문자 코드(2 bytes) 이후의 파라미터(12 bytes) 파싱 / Parse parameter (12 bytes) after control character code (2 bytes) if idx + 2 + 12 <= data.len() { let param_data = &data[idx + 2..idx + 2 + 12]; if let Ok(param) = crate::document::bodytext::control_char::InlineControlParam::parse(control_code, param_data) { inline_control_params.push((char_idx, param)); } } } // 텍스트로 표현 가능한 제어 문자는 텍스트에 변환된 형태로 추가 / Add convertible control characters as converted text // 단, PARA_BREAK와 LINE_BREAK는 control_char_positions에만 저장하고 텍스트에는 포함하지 않음 // However, PARA_BREAK and LINE_BREAK are only stored in control_char_positions, not added to text if ControlChar::is_convertible(control_code) { // PARA_BREAK와 LINE_BREAK는 텍스트에 추가하지 않음 (control_char_positions에만 저장) // Don't add PARA_BREAK and LINE_BREAK to text (only store in control_char_positions) if control_code != ControlChar::PARA_BREAK && control_code != ControlChar::LINE_BREAK { if let Some(text_repr) = ControlChar::to_text(control_code) { cleaned_text.push_str(text_repr); runs.push(ParaTextRun::Text { text: text_repr.to_string(), }); } } } // 제거해야 할 제어 문자는 텍스트에 추가하지 않음 / Don't add removable control characters to text idx += control_size; // 제어 문자와 파라미터 건너뛰기 / Skip control character and parameters } else { // 텍스트 부분 디코딩 / Decode text portion // 다음 제어 문자까지 또는 끝까지 / Until next control character or end let mut text_end = idx; while text_end < data.len() { if text_end + 1 < data.len() { let code = data[text_end] as u32; if code <= 31 && data[text_end + 1] == 0 { break; // 제어 문자 발견 / Control character found } } text_end += 2; // UTF-16LE는 2바이트 단위 / UTF-16LE is 2-byte units } if text_end > idx { // 텍스트 부분 디코딩 / Decode text portion let text_bytes = &data[idx..text_end]; if let Ok(text) = decode_utf16le(text_bytes) { cleaned_text.push_str(&text); if !text.is_empty() { runs.push(ParaTextRun::Text { text }); } } idx = text_end; } else { // 더 이상 처리할 데이터 없음 / No more data to process break; } } } Ok(ParagraphRecord::ParaText { text: cleaned_text, runs, control_char_positions, inline_control_params, }) } HwpTag::PARA_CHAR_SHAPE => { let para_char_shape = ParaCharShape::parse(node.data()).map_err(\|e\| HwpError::from(e))?; Ok(ParagraphRecord::ParaCharShape { shapes: para_char_shape.shapes, }) } HwpTag::PARA_LINE_SEG => { let para_line_seg = ParaLineSeg::parse(node.data()).map_err(\|e\| HwpError::from(e))?; Ok(ParagraphRecord::ParaLineSeg { segments: para_line_seg.segments, }) } HwpTag::PARA_RANGE_TAG => { let para_range_tag = ParaRangeTag::parse(node.data()).map_err(\|e\| HwpError::from(e))?; Ok(ParagraphRecord::ParaRangeTag { tags: para_range_tag.tags, }) } HwpTag::CTRL_HEADER => { let ctrl_header = CtrlHeader::parse(node.data()).map_err(\|e\| HwpError::from(e))?; // 디버그: CTRL_HEADER 파싱 시작 / Debug: Start parsing CTRL_HEADER use crate::document::bodytext::ctrl_header::CtrlId; #[cfg(debug_assertions)] eprintln!( "[DEBUG] Parsing CTRL_HEADER: ctrl_id={:?}, ctrl_id_value={}", ctrl_header.ctrl_id, ctrl_header.ctrl_id_value ); // 자식 레코드들을 재귀적으로 처리 / Recursively process child records // hwp.js: visitControlHeader에서 record.children를 모두 처리 // hwp.js: visitControlHeader processes all record.children // hwp.js: visitListHeader에서 record.parentTagID === HWPTAG_CTRL_HEADER이고 isTable(control)일 때 테이블 셀로 처리 // hwp.js: visitListHeader processes as table cell when record.parentTagID === HWPTAG_CTRL_HEADER and isTable(control) let mut children = Vec::new(); let mut table_opt: Option<crate::document::bodytext::Table> = None; let mut list_headers_for_table: Vec<( u16, u16, Vec<super::Paragraph>, Option<crate::document::bodytext::table::CellAttributes>, )> = Vec::new(); // (row_address, col_address, paragraphs, cell_attributes) // CTRL_HEADER가 테이블인지 확인 / Check if CTRL_HEADER is a table // hwp.js: CommonCtrlID.Table = makeCtrlID('t', 'b', 'l', ' ') = 0x206C6274 (little-endian: 0x74626C20) // hwp.js: CommonCtrlID.Table = makeCtrlID('t', 'b', 'l', ' ') = 0x206C6274 (little-endian: 0x74626C20) // pyhwp: CHID.TBL = 'tbl ' (바이트 리버스 후) / pyhwp: CHID.TBL = 'tbl ' (after byte reverse) let is_table = ctrl_header.ctrl_id == CtrlId::TABLE \|\| ctrl_header.ctrl_id_value == 0x74626C20u32; let mut paragraphs = Vec::new(); // libhwp 방식: TABLE 위치를 먼저 찾아서 TABLE 이후의 LIST_HEADER는 children에 추가하지 않음 // libhwp approach: Find TABLE position first, then don't add LIST_HEADERs after TABLE to children let children_slice: Vec<_> = node.children().iter().collect(); // TABLE 이전의 LIST_HEADER를 찾아서 캡션으로 파싱 / Find LIST_HEADER before TABLE and parse as caption // hwplib과 hwp-rs 방식: 별도 레코드로 캡션 처리 / hwplib and hwp-rs approach: process caption as separate record let mut caption_opt: Option<Caption> = None; // TABLE 위치 찾기 / Find TABLE position let table_index = if is_table { children_slice .iter() .position(\|child\| child.tag_id() == HwpTag::TABLE) } else { None }; if is_table { if let Some(table_idx) = table_index { // TABLE 이전의 LIST_HEADER 찾기 / Find LIST_HEADER before TABLE for child in children_slice.iter().take(table_idx) { if child.tag_id() == HwpTag::LIST_HEADER { // 캡션으로 파싱 / Parse as caption use crate::document::bodytext::ctrl_header::parse_caption_from_list_header; caption_opt = parse_caption_from_list_header(child.data())?; break; // 첫 번째 LIST_HEADER만 캡션으로 처리 / Only process first LIST_HEADER as caption } } } } // CTRL_HEADER가 LIST_HEADER를 가지고 있는지 먼저 확인 (머리말/꼬리말/각주/미주의 경우) // Check if CTRL_HEADER has LIST_HEADER first (for headers/footers/footnotes/endnotes) // PARA_HEADER 처리 전에 확인하여 중복 방지 // Check before processing PARA_HEADER to avoid duplication let has_list_header = children_slice .iter() .any(\|child\| child.tag_id() == HwpTag::LIST_HEADER && !is_table); for (idx, child) in children_slice.iter().enumerate() { if child.tag_id() == HwpTag::TABLE { // TABLE은 별도로 처리 / TABLE is processed separately let table_data = Table::parse(child.data(), version).map_err(\|e\| HwpError::from(e))?;	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	true
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/list_header.rs	crates/hwp-core/src/document/bodytext/list_header.rs	/// ListHeader 구조체 / ListHeader structure /// /// 스펙 문서 매핑: 표 65 - 문단 리스트 헤더 / Spec mapping: Table 65 - Paragraph list header use crate::error::HwpError; use crate::types::{INT16, UINT32}; use serde::{Deserialize, Serialize}; /// 문단 리스트 헤더 / Paragraph list header #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ListHeader { /// 문단 수 / Paragraph count pub paragraph_count: INT16, /// 속성 (표 65-1 참조) / Attribute (see Table 65-1) pub attribute: ListHeaderAttribute, } /// 문단 리스트 헤더 속성 (표 65-1) / Paragraph list header attribute (Table 65-1) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ListHeaderAttribute { /// 텍스트 방향 / Text direction pub text_direction: TextDirection, /// 문단의 줄바꿈 / Paragraph line break pub line_break: LineBreak, /// 세로 정렬 / Vertical alignment pub vertical_align: VerticalAlign, } /// 텍스트 방향 / Text direction #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum TextDirection { /// 가로 / Horizontal Horizontal, /// 세로 / Vertical Vertical, } /// 문단의 줄바꿈 / Paragraph line break #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum LineBreak { /// 일반적인 줄바꿈 / Normal line break Normal, /// 자간을 조종하여 한 줄을 유지 / Maintain one line by adjusting character spacing MaintainOneLine, /// 내용에 따라 폭이 늘어남 / Width increases according to content ExpandByContent, } /// 세로 정렬 / Vertical alignment #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum VerticalAlign { /// 위쪽 / Top Top, /// 가운데 / Center Center, /// 아래쪽 / Bottom Bottom, } impl ListHeader { /// ListHeader를 바이트 배열에서 파싱합니다. / Parse ListHeader from byte array. /// /// # Arguments /// * `data` - 최소 6바이트의 데이터 / At least 6 bytes of data /// /// # Returns /// 파싱된 ListHeader 구조체 / Parsed ListHeader structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // 표 65에는 6바이트로 되어있지만 실제 파일/구현에서는 // - 6바이트: [paragraph_count:2][attribute:4] // - 8바이트: [paragraph_count:2][unknown1:2][attribute:4] // 변형이 존재합니다. pyhwp는 8바이트 구조를 기본으로 사용합니다. // 따라서 최소 6바이트를 허용하되, 8바이트 이상이면 8바이트 구조를 우선합니다. if data.len() < 6 { return Err(HwpError::insufficient_data("ListHeader", 6, data.len())); } // INT16 문단 수 / INT16 paragraph count let paragraph_count = INT16::from_le_bytes([data[0], data[1]]); // UINT32 속성 (표 65-1 참조) / UINT32 attribute (see Table 65-1) // 6바이트 구조: [paragraph_count:2][attribute:4] // 8바이트 구조: [paragraph_count:2][unknown1:2][attribute:4] let attribute_value = if data.len() >= 8 { UINT32::from_le_bytes([data[4], data[5], data[6], data[7]]) } else { UINT32::from_le_bytes([data[2], data[3], data[4], data[5]]) }; // 속성 파싱 (표 65-1) / Parse attribute (Table 65-1) let attribute = parse_list_header_attribute(attribute_value); Ok(ListHeader { paragraph_count, attribute, }) } } /// 문단 리스트 헤더 속성 파싱 (표 65-1) / Parse list header attribute (Table 65-1) fn parse_list_header_attribute(value: UINT32) -> ListHeaderAttribute { // bit 0-2: 텍스트 방향 / bit 0-2: text direction let text_direction = match value & 0x07 { 0 => TextDirection::Horizontal, 1 => TextDirection::Vertical, _ => TextDirection::Horizontal, }; // bit 3-4: 문단의 줄바꿈 / bit 3-4: paragraph line break let line_break = match (value >> 3) & 0x03 { 0 => LineBreak::Normal, 1 => LineBreak::MaintainOneLine, 2 => LineBreak::ExpandByContent, _ => LineBreak::Normal, }; // bit 5-6: 세로 정렬 / bit 5-6: vertical alignment let vertical_align = match (value >> 5) & 0x03 { // 스펙(표 65-1): 0=top, 1=center, 2=bottom 0 => VerticalAlign::Top, 1 => VerticalAlign::Center, 2 => VerticalAlign::Bottom, _ => VerticalAlign::Top, }; ListHeaderAttribute { text_direction, line_break, vertical_align, } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/constants.rs	crates/hwp-core/src/document/bodytext/constants.rs	/// BodyText 레코드 태그 상수 정의 / BodyText record tag constants definition /// /// 스펙 문서 매핑: 표 57 - 본문의 데이터 레코드 / Spec mapping: Table 57 - BodyText data records use crate::document::constants::HWPTAG_BEGIN; /// BodyText 태그 상수 / BodyText tag constants pub struct HwpTag; impl HwpTag { /// 문단 헤더 / Paragraph header pub const PARA_HEADER: u16 = HWPTAG_BEGIN + 50; /// 문단의 텍스트 / Paragraph text pub const PARA_TEXT: u16 = HWPTAG_BEGIN + 51; /// 문단의 글자 모양 / Paragraph character shape pub const PARA_CHAR_SHAPE: u16 = HWPTAG_BEGIN + 52; /// 문단의 레이아웃 / Paragraph line segment pub const PARA_LINE_SEG: u16 = HWPTAG_BEGIN + 53; /// 문단의 영역 태그 / Paragraph range tag pub const PARA_RANGE_TAG: u16 = HWPTAG_BEGIN + 54; /// 컨트롤 헤더 / Control header pub const CTRL_HEADER: u16 = HWPTAG_BEGIN + 55; /// 문단 리스트 헤더 / Paragraph list header pub const LIST_HEADER: u16 = HWPTAG_BEGIN + 56; /// 용지 설정 / Page definition pub const PAGE_DEF: u16 = HWPTAG_BEGIN + 57; /// 각주/미주 모양 / Footnote/endnote shape pub const FOOTNOTE_SHAPE: u16 = HWPTAG_BEGIN + 58; /// 쪽 테두리/배경 / Page border/fill pub const PAGE_BORDER_FILL: u16 = HWPTAG_BEGIN + 59; /// 개체 / Shape component pub const SHAPE_COMPONENT: u16 = HWPTAG_BEGIN + 60; /// 표 개체 / Table object pub const TABLE: u16 = HWPTAG_BEGIN + 61; /// 직선 개체 / Line shape component pub const SHAPE_COMPONENT_LINE: u16 = HWPTAG_BEGIN + 62; /// 사각형 개체 / Rectangle shape component pub const SHAPE_COMPONENT_RECTANGLE: u16 = HWPTAG_BEGIN + 63; /// 타원 개체 / Ellipse shape component pub const SHAPE_COMPONENT_ELLIPSE: u16 = HWPTAG_BEGIN + 64; /// 호 개체 / Arc shape component pub const SHAPE_COMPONENT_ARC: u16 = HWPTAG_BEGIN + 65; /// 다각형 개체 / Polygon shape component pub const SHAPE_COMPONENT_POLYGON: u16 = HWPTAG_BEGIN + 66; /// 곡선 개체 / Curve shape component pub const SHAPE_COMPONENT_CURVE: u16 = HWPTAG_BEGIN + 67; /// OLE 개체 / OLE shape component pub const SHAPE_COMPONENT_OLE: u16 = HWPTAG_BEGIN + 68; /// 그림 개체 / Picture shape component pub const SHAPE_COMPONENT_PICTURE: u16 = HWPTAG_BEGIN + 69; /// 컨테이너 개체 / Container shape component pub const SHAPE_COMPONENT_CONTAINER: u16 = HWPTAG_BEGIN + 70; /// 컨트롤 임의의 데이터 / Control arbitrary data pub const CTRL_DATA: u16 = HWPTAG_BEGIN + 71; /// 수식 개체 / Equation editor pub const EQEDIT: u16 = HWPTAG_BEGIN + 72; /// 예약 / Reserved pub const RESERVED: u16 = HWPTAG_BEGIN + 73; /// 글맵시 / Text art shape component pub const SHAPE_COMPONENT_TEXTART: u16 = HWPTAG_BEGIN + 74; /// 양식 개체 / Form object pub const FORM_OBJECT: u16 = HWPTAG_BEGIN + 75; /// 메모 모양 / Memo shape pub const MEMO_SHAPE: u16 = HWPTAG_BEGIN + 76; /// 메모 리스트 헤더 / Memo list header pub const MEMO_LIST: u16 = HWPTAG_BEGIN + 77; /// 차트 데이터 / Chart data pub const CHART_DATA: u16 = HWPTAG_BEGIN + 79; /// 비디오 데이터 / Video data pub const VIDEO_DATA: u16 = HWPTAG_BEGIN + 82; /// Unknown 개체 / Unknown shape component pub const SHAPE_COMPONENT_UNKNOWN: u16 = HWPTAG_BEGIN + 99; }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_data.rs	crates/hwp-core/src/document/bodytext/ctrl_data.rs	/// CtrlData 구조체 / CtrlData structure /// /// 스펙 문서 매핑: 표 66 - 컨트롤 임의의 데이터 / Spec mapping: Table 66 - Control arbitrary data /// /// 구현 상태 / Implementation Status /// - 구현 완료 / Implementation complete /// - 테스트 파일(`noori.hwp`)에 CTRL_DATA 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain CTRL_DATA records use crate::document::docinfo::ParameterSet; use crate::error::HwpError; use serde::{Deserialize, Serialize}; /// 컨트롤 임의의 데이터 / Control arbitrary data #[derive(Debug, Clone, Serialize, Deserialize)] pub struct CtrlData { /// 파라미터 셋 (표 50 참조) / Parameter set (see Table 50) pub parameter_set: ParameterSet, } impl CtrlData { /// CtrlData를 바이트 배열에서 파싱합니다. / Parse CtrlData from byte array. /// /// # Arguments /// * `data` - CtrlData 데이터 / CtrlData data /// /// # Returns /// 파싱된 CtrlData 구조체 / Parsed CtrlData structure /// /// # Note /// 스펙 문서 표 66에 따르면 CTRL_DATA는 다음 구조를 가집니다: /// - Parameter Set (표 50 참조) - 가변 길이 /// /// 레거시 코드(hwp.js)는 CTRL_DATA를 파싱하지 않고 있습니다. /// According to spec Table 66, CTRL_DATA has the following structure: /// - Parameter Set (Table 50) - variable length /// /// Legacy code (hwp.js) does not parse CTRL_DATA. /// /// 테스트 상태 / Testing Status /// 현재 테스트 파일(`noori.hwp`)에 CTRL_DATA 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 CTRL_DATA 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain CTRL_DATA records, so it has not been verified with actual files. /// If an actual HWP file contains CTRL_DATA records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.is_empty() { return Err(HwpError::InsufficientData { field: "CtrlData data".to_string(), expected: 1, actual: 0, }); } // 파라미터 셋 파싱 (표 50) / Parse parameter set (Table 50) let parameter_set = ParameterSet::parse(data) .map_err(\|e\| HwpError::from(e))?; Ok(CtrlData { parameter_set }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/para_header.rs	crates/hwp-core/src/document/bodytext/para_header.rs	/// ParaHeader 구조체 / ParaHeader structure /// /// 스펙 문서 매핑: 표 58 - 문단 헤더 / Spec mapping: Table 58 - Paragraph header /// Tag ID: HWPTAG_PARA_HEADER /// 전체 길이: 24바이트 (5.0.3.2 이상) / Total length: 24 bytes (5.0.3.2 and above) /// /// 레벨별 사용 / Usage by Level /// /// - Level 0: 본문의 문단 헤더 (일반적인 사용) / Paragraph header in body text (normal usage) /// - `Section::parse_data`에서 처리되어 `Paragraph` 구조체의 `para_header` 필드로 저장됨 /// - Processed in `Section::parse_data` and stored in `Paragraph` struct's `para_header` field /// /// - Level 1 이상: 컨트롤 헤더 내부의 문단 헤더 / Paragraph header inside control header /// - 각주/미주(`fn `, `en `), 머리말/꼬리말(`head`, `foot`) 등의 컨트롤 헤더 내부에 직접 나타날 수 있음 /// - Can appear directly inside control headers like footnotes/endnotes (`fn `, `en `), headers/footers (`head`, `foot`), etc. /// - `CtrlHeader`의 children에서 처리되어 `ParagraphRecord::CtrlHeader`의 `paragraphs` 필드에 저장됨 /// - Processed in `CtrlHeader`'s children and stored in `ParagraphRecord::CtrlHeader`'s `paragraphs` field /// - 레거시 코드 참고: `legacy/ruby-hwp/lib/hwp/model.rb`의 `Footnote`, `Header`, `Footer` 등에서 /// `@ctrl_header.para_headers << para_header`로 처리됨 /// - Reference: `legacy/ruby-hwp/lib/hwp/model.rb`'s `Footnote`, `Header`, `Footer`, etc. /// where `@ctrl_header.para_headers << para_header` use crate::error::HwpError; use crate::types::{UINT16, UINT32, UINT8}; use serde::{Deserialize, Serialize}; /// Control Mask 구조체 / Control Mask structure /// /// libhwp의 HWPControlMask를 참고하여 구현 /// 각 비트는 `(UINT32)(1<<ctrich) 조합`으로, 특정 제어 문자의 존재 여부를 나타냅니다. /// Control mask structure /// /// Implemented based on libhwp's HWPControlMask /// Each bit represents `(UINT32)(1<<ctrich) combination`, indicating the presence of specific control characters. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct ControlMask { /// 원본 값 / Raw value pub value: UINT32, } impl Serialize for ControlMask { fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer, { use serde::ser::SerializeMap; let active_flags = self.active_flags(); let mut map = serializer.serialize_map(Some(2))?; map.serialize_entry("value", &self.value)?; map.serialize_entry("flags", &active_flags)?; map.end() } } impl<'de> Deserialize<'de> for ControlMask { fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de>, { // 기존 호환성: 숫자로 직렬화된 경우도 처리 / Backward compatibility: handle numeric serialization // 새로운 형식: 객체로 직렬화된 경우도 처리 / New format: handle object serialization struct ControlMaskVisitor; impl<'de> serde::de::Visitor<'de> for ControlMaskVisitor { type Value = ControlMask; fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result { formatter.write_str("control mask as u32 or object with value and flags") } // 숫자로 직렬화된 경우 (기존 형식) / Numeric serialization (old format) fn visit_u32<E>(self, value: u32) -> Result<Self::Value, E> where E: serde::de::Error, { Ok(ControlMask::new(value)) } fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E> where E: serde::de::Error, { Ok(ControlMask::new(value as u32)) } // 객체로 직렬화된 경우 (새 형식) / Object serialization (new format) fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error> where M: serde::de::MapAccess<'de>, { let mut value: Option<UINT32> = None; let mut flags: Option<Vec<String>> = None; while let Some(key) = map.next_key::<String>()? { match key.as_str() { "value" => { if value.is_some() { return Err(serde::de::Error::duplicate_field("value")); } value = Some(map.next_value()?); } "flags" => { if flags.is_some() { return Err(serde::de::Error::duplicate_field("flags")); } flags = Some(map.next_value()?); } _ => { let _ = map.next_value::<serde::de::IgnoredAny>()?; } } } let value = value.ok_or_else(\|\| serde::de::Error::missing_field("value"))?; // flags는 무시하고 value만 사용 (flags는 value에서 계산 가능) / Ignore flags and use only value (flags can be calculated from value) Ok(ControlMask::new(value)) } } deserializer.deserialize_any(ControlMaskVisitor) } } impl ControlMask { /// ControlMask를 생성합니다. / Create a ControlMask. pub fn new(value: UINT32) -> Self { Self { value } } /// 원본 값을 반환합니다. / Returns the raw value. pub fn value(&self) -> UINT32 { self.value } /// 비트가 설정되어 있는지 확인합니다. / Check if a bit is set. fn has_bit(&self, bit: u32) -> bool { (self.value & (1u32 << bit)) != 0 } /// 구역/단 정의 컨트롤을 가졌는지 여부 / Whether the paragraph has section/column definition control /// bit 2 (Ch 2) pub fn has_sect_col_def(&self) -> bool { self.has_bit(2) } /// 필드 시작 컨트롤을 가졌는지 여부 / Whether the paragraph has field start control /// bit 3 (Ch 3) pub fn has_field_start(&self) -> bool { self.has_bit(3) } /// 필드 끝 컨트롤을 가졌는지 여부 / Whether the paragraph has field end control /// bit 4 (Ch 4) pub fn has_field_end(&self) -> bool { self.has_bit(4) } /// Title Mark를 가졌는지 여부 / Whether the paragraph has title mark /// bit 8 (Ch 8) pub fn has_title_mark(&self) -> bool { self.has_bit(8) } /// 탭을 가졌는지 여부 / Whether the paragraph has tab /// bit 9 (Ch 9) pub fn has_tab(&self) -> bool { self.has_bit(9) } /// 강제 줄 나눔을 가졌는지 여부 / Whether the paragraph has line break /// bit 10 (Ch 10) pub fn has_line_break(&self) -> bool { self.has_bit(10) } /// 그리기 객체 또는 표 객체를 가졌는지 여부 / Whether the paragraph has drawing object or table /// bit 11 (Ch 11) pub fn has_gso_table(&self) -> bool { self.has_bit(11) } /// 문단 나누기를 가졌는지 여부 / Whether the paragraph has paragraph break /// bit 13 (Ch 13) pub fn has_para_break(&self) -> bool { self.has_bit(13) } /// 숨은 설명을 가졌는지 여부 / Whether the paragraph has hidden comment /// bit 15 (Ch 15) pub fn has_hidden_comment(&self) -> bool { self.has_bit(15) } /// 머리말 또는 꼬리말을 가졌는지 여부 / Whether the paragraph has header/footer /// bit 16 (Ch 16) pub fn has_header_footer(&self) -> bool { self.has_bit(16) } /// 각주 또는 미주를 가졌는지 여부 / Whether the paragraph has footnote/endnote /// bit 17 (Ch 17) pub fn has_footnote_endnote(&self) -> bool { self.has_bit(17) } /// 자동 번호를 가졌는지 여부 / Whether the paragraph has auto number /// bit 18 (Ch 18) pub fn has_auto_number(&self) -> bool { self.has_bit(18) } /// 페이지 컨트롤을 가졌는지 여부 / Whether the paragraph has page control /// bit 21 (Ch 21) pub fn has_page_control(&self) -> bool { self.has_bit(21) } /// 책갈피/찾아보기 표시를 가졌는지 여부 / Whether the paragraph has bookmark/index mark /// bit 22 (Ch 22) pub fn has_bookmark(&self) -> bool { self.has_bit(22) } /// 덧말/글자 겹침을 가졌는지 여부 / Whether the paragraph has additional text overlapping letter /// bit 23 (Ch 23) pub fn has_additional_text_overlapping_letter(&self) -> bool { self.has_bit(23) } /// 하이픈을 가졌는지 여부 / Whether the paragraph has hyphen /// bit 24 (Ch 24) pub fn has_hyphen(&self) -> bool { self.has_bit(24) } /// 묶음 빈칸을 가졌는지 여부 / Whether the paragraph has bundle blank /// bit 30 (Ch 30) pub fn has_bundle_blank(&self) -> bool { self.has_bit(30) } /// 고정 폭 빈칸을 가졌는지 여부 / Whether the paragraph has fixed width blank /// bit 31 (Ch 31) pub fn has_fix_width_blank(&self) -> bool { self.has_bit(31) } /// 활성화된 모든 플래그를 문자열 배열로 반환합니다. / Returns all active flags as a string array. pub fn active_flags(&self) -> Vec<&'static str> { let mut flags = Vec::new(); if self.has_sect_col_def() { flags.push("section_column_definition"); } if self.has_field_start() { flags.push("field_start"); } if self.has_field_end() { flags.push("field_end"); } if self.has_title_mark() { flags.push("title_mark"); } if self.has_tab() { flags.push("tab"); } if self.has_line_break() { flags.push("line_break"); } if self.has_gso_table() { flags.push("gso_table"); } if self.has_para_break() { flags.push("paragraph_break"); } if self.has_hidden_comment() { flags.push("hidden_comment"); } if self.has_header_footer() { flags.push("header_footer"); } if self.has_footnote_endnote() { flags.push("footnote_endnote"); } if self.has_auto_number() { flags.push("auto_number"); } if self.has_page_control() { flags.push("page_control"); } if self.has_bookmark() { flags.push("bookmark"); } if self.has_additional_text_overlapping_letter() { flags.push("additional_text_overlapping_letter"); } if self.has_hyphen() { flags.push("hyphen"); } if self.has_bundle_blank() { flags.push("bundle_blank"); } if self.has_fix_width_blank() { flags.push("fix_width_blank"); } flags } } impl From<UINT32> for ControlMask { fn from(value: UINT32) -> Self { Self::new(value) } } impl From<ControlMask> for UINT32 { fn from(mask: ControlMask) -> Self { mask.value } } /// 단 나누기 종류 / Column divide type #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum ColumnDivideType { /// 구역 나누기 / Section divide Section = 0x01, /// 다단 나누기 / Multi-column divide MultiColumn = 0x02, /// 쪽 나누기 / Page divide Page = 0x04, /// 단 나누기 / Column divide Column = 0x08, } impl ColumnDivideType { fn from_bits(bits: u8) -> Vec<Self> { let mut types = Vec::new(); if bits & 0x01 != 0 { types.push(ColumnDivideType::Section); } if bits & 0x02 != 0 { types.push(ColumnDivideType::MultiColumn); } if bits & 0x04 != 0 { types.push(ColumnDivideType::Page); } if bits & 0x08 != 0 { types.push(ColumnDivideType::Column); } types } } /// 문단 헤더 구조체 / Paragraph header structure #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ParaHeader { /// 텍스트 문자 수 / Text character count /// `if (nchars & 0x80000000) { nchars &= 0x7fffffff; }` pub text_char_count: UINT32, /// 컨트롤 마스크 / Control mask /// `(UINT32)(1<<ctrich) 조합` /// JSON 직렬화 시 value만 직렬화하여 기존 호환성 유지 / Only value is serialized in JSON to maintain backward compatibility pub control_mask: ControlMask, /// 문단 모양 아이디 참조값 / Paragraph shape ID reference pub para_shape_id: UINT16, /// 문단 스타일 아이디 참조값 / Paragraph style ID reference pub para_style_id: UINT8, /// 단 나누기 종류 / Column divide type pub column_divide_type: Vec<ColumnDivideType>, /// 글자 모양 정보 수 / Character shape info count pub char_shape_count: UINT16, /// range tag 정보 수 / Range tag info count pub range_tag_count: UINT16, /// 각 줄에 대한 align에 대한 정보 수 / Line align info count pub line_align_count: UINT16, /// 문단 Instance ID (unique ID) / Paragraph instance ID pub instance_id: UINT32, /// 변경추적 병합 문단여부 (5.0.3.2 버전 이상) / Track change merge paragraph flag (5.0.3.2 and above) pub section_merge: Option<UINT16>, } impl Default for ParaHeader { fn default() -> Self { Self { text_char_count: 0, control_mask: ControlMask::new(0), para_shape_id: 0, para_style_id: 0, column_divide_type: Vec::new(), char_shape_count: 0, range_tag_count: 0, line_align_count: 0, instance_id: 0, section_merge: None, } } } impl ParaHeader { /// ParaHeader를 바이트 배열에서 파싱합니다. / Parse ParaHeader from byte array. /// /// # Arguments /// * `data` - 최소 22바이트의 데이터 (5.0.3.2 이상은 24바이트) / At least 22 bytes of data (24 bytes for 5.0.3.2 and above) /// * `version` - 파일 버전 (5.0.3.2 이상인지 확인용) / File version (to check if 5.0.3.2 and above) /// /// # Returns /// 파싱된 ParaHeader 구조체 / Parsed ParaHeader structure pub fn parse(data: &[u8], version: u32) -> Result<Self, HwpError> { // 최소 22바이트 필요 (5.0.3.2 이상은 24바이트) / Need at least 22 bytes (24 bytes for 5.0.3.2 and above) let min_size = if version >= 0x05000302 { 24 } else { 22 }; if data.len() < min_size { return Err(HwpError::insufficient_data("ParaHeader", min_size, data.len())); } let mut offset = 0; // UINT32 text(=chars) / UINT32 text character count let mut text_char_count = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); // `if (nchars & 0x80000000) { nchars &= 0x7fffffff; }` if text_char_count & 0x80000000 != 0 { text_char_count &= 0x7fffffff; } offset += 4; // UINT32 control mask / UINT32 control mask let control_mask_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); let control_mask = ControlMask::new(control_mask_value); offset += 4; // UINT16 문단 모양 아이디 참조값 / UINT16 paragraph shape ID reference let para_shape_id = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT8 문단 스타일 아이디 참조값 / UINT8 paragraph style ID reference let para_style_id = data[offset]; offset += 1; // UINT8 단 나누기 종류 / UINT8 column divide type let column_divide_bits = data[offset]; let column_divide_type = ColumnDivideType::from_bits(column_divide_bits); offset += 1; // UINT16 글자 모양 정보 수 / UINT16 character shape info count let char_shape_count = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT16 range tag 정보 수 / UINT16 range tag info count let range_tag_count = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT16 각 줄에 대한 align에 대한 정보 수 / UINT16 line align info count let line_align_count = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT32 문단 Instance ID / UINT32 paragraph instance ID let instance_id = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // UINT16 변경추적 병합 문단여부 (5.0.3.2 버전 이상) / UINT16 track change merge paragraph flag (5.0.3.2 and above) let section_merge = if version >= 0x05000302 && data.len() >= 24 { Some(UINT16::from_le_bytes([data[offset], data[offset + 1]])) } else { None }; Ok(ParaHeader { text_char_count, control_mask, para_shape_id, para_style_id, column_divide_type, char_shape_count, range_tag_count, line_align_count, instance_id, section_merge, }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/control_char.rs	crates/hwp-core/src/document/bodytext/control_char.rs	/// Control character constants based on HWP 5.0 Specification Table 6 /// HWP 5.0 스펙 표 6 기반 제어 문자 상수 /// /// 표 6: 제어 문자 / Table 6: Control characters use crate::error::HwpError; use serde::{Deserialize, Serialize}; pub struct ControlChar; /// 제어 문자 위치 정보 / Control character position information /// /// 문단 텍스트 내에서 제어 문자의 위치와 종류를 나타냅니다. /// Represents the position and type of control characters within paragraph text. #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ControlCharPosition { /// 문자 인덱스 (텍스트 내 위치) / Character index (position in text) pub position: usize, /// 제어 문자 코드 (0-31) / Control character code (0-31) pub code: u8, /// 제어 문자 이름 (상수 이름) / Control character name (constant name) pub name: String, } /// INLINE 제어 문자 파라미터 / INLINE control character parameter /// /// JSON으로 표현 가능한 의미 있는 값만 저장합니다. /// Only stores meaningful values that can be expressed in JSON. /// /// INLINE 타입 제어 문자는 제어 문자 1 WCHAR (2 bytes) + 파라미터 6 WCHAR (12 bytes) = 총 8 WCHAR (16 bytes) /// INLINE type control characters: control char 1 WCHAR (2 bytes) + parameter 6 WCHAR (12 bytes) = total 8 WCHAR (16 bytes) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct InlineControlParam { /// TAB 제어 문자의 너비 (HWPUNIT, 1/7200인치) / Width for TAB control character (HWPUNIT, 1/7200 inch) /// TAB (0x09)의 경우 첫 4바이트를 UINT32로 읽어서 저장 / For TAB (0x09), first 4 bytes read as UINT32 #[serde(skip_serializing_if = "Option::is_none")] pub width: Option<crate::types::HWPUNIT>, /// 컨트롤 ID (4바이트 ASCII 문자열) / Control ID (4-byte ASCII string) /// 다른 INLINE 타입의 경우 첫 4바이트를 ASCII로 읽기 시도 / For other INLINE types, attempt to read first 4 bytes as ASCII /// 스펙 문서에 명시되지 않은 식별자로, 정확한 의미는 알 수 없음 / Unspecified identifier in spec document, exact meaning is unknown #[serde(skip_serializing_if = "Option::is_none")] pub chid: Option<String>, } impl InlineControlParam { /// INLINE 제어 문자 파라미터를 바이트 배열에서 파싱합니다. / Parse INLINE control character parameter from byte array. /// /// # Arguments /// * `control_code` - 제어 문자 코드 / Control character code /// * `data` - 최소 12바이트의 데이터 (제어 문자 코드 이후의 데이터) / At least 12 bytes of data (data after control character code) /// /// # Returns /// 파싱된 InlineControlParam 구조체 / Parsed InlineControlParam structure pub fn parse(control_code: u8, data: &[u8]) -> Result<Self, HwpError> { if data.len() < 12 { return Err(HwpError::insufficient_data("InlineControlParam", 12, data.len())); } let mut param = InlineControlParam { width: None, chid: None, }; if control_code == ControlChar::TAB { // TAB의 경우: 첫 4바이트를 UINT32로 읽어서 width로 저장 // For TAB: read first 4 bytes as UINT32 and store as width use crate::types::UINT32; let width_value = UINT32::from_le_bytes([data[0], data[1], data[2], data[3]]); param.width = Some(crate::types::HWPUNIT::from(width_value)); } else { // 다른 INLINE 타입의 경우: 첫 4바이트를 ASCII 문자열로 읽기 시도 // For other INLINE types: attempt to read first 4 bytes as ASCII string // 스펙 문서에 파라미터 구조가 명시되지 않아 정확한 의미를 알 수 없는 식별자 // Parameter structure not specified in spec document, exact meaning of identifier is unknown let chid_bytes = &data[0..4]; // ASCII로 읽을 수 있는지 확인 (모든 바이트가 0x20-0x7E 범위이거나 0x00) // Check if can be read as ASCII (all bytes in range 0x20-0x7E or 0x00) if chid_bytes .iter() .all(\|&b\| b == 0 \|\| (b >= 0x20 && b <= 0x7E)) { let chid_str = String::from_utf8_lossy(chid_bytes) .trim_end_matches('\0') .to_string(); if !chid_str.is_empty() { param.chid = Some(chid_str); } } } Ok(param) } } impl ControlChar { // Char control characters / 문자 제어 문자 /// NULL 문자 / NULL character /// 표 6에는 명시되지 않았지만 CHAR 타입으로 처리됨 / Not specified in Table 6 but handled as CHAR type pub const NULL: u8 = 0; // Extended control characters / 확장 제어 문자 /// 예약 (1-3) / Reserved (1-3) /// 표 6에는 명시되지 않았지만 EXTENDED 타입으로 처리됨 / Not specified in Table 6 but handled as EXTENDED type pub const RESERVED_1_3_START: u8 = 1; pub const RESERVED_1_3_END: u8 = 3; // Inline control characters / 인라인 제어 문자 /// 필드 끝 / Field end pub const FIELD_END: u8 = 4; /// 예약 (5-7) / Reserved (5-7) pub const RESERVED_5_7_START: u8 = 5; pub const RESERVED_5_7_END: u8 = 7; /// title mark pub const TITLE_MARK: u8 = 8; /// 탭 / Tab pub const TAB: u8 = 9; /// 예약 (19-20) / Reserved (19-20) pub const RESERVED_19_20_START: u8 = 19; pub const RESERVED_19_20_END: u8 = 20; // Char control characters (continued) / 문자 제어 문자 (계속) /// 한 줄 끝(line break) / Line break pub const LINE_BREAK: u8 = 10; /// 문단 끝(para break) / Paragraph break pub const PARA_BREAK: u8 = 13; /// 하이픈 / Hyphen pub const HYPHEN: u8 = 24; /// 예약 (25-29) / Reserved (25-29) pub const RESERVED_25_29_START: u8 = 25; pub const RESERVED_25_29_END: u8 = 29; /// 묶음 빈칸 / Bound space pub const BOUND_SPACE: u8 = 30; /// 고정폭 빈칸 / Fixed-width space pub const FIXED_SPACE: u8 = 31; // Extended control characters / 확장 제어 문자 /// 그리기 개체/표 / Drawing object/table pub const SHAPE_OBJECT: u8 = 11; /// 예약 (12) / Reserved (12) pub const RESERVED_12: u8 = 12; /// 예약 (14) / Reserved (14) pub const RESERVED_14: u8 = 14; /// 숨은 설명 / Hidden description pub const HIDDEN_DESC: u8 = 15; /// 머리말/꼬리말 / Header/footer /// 제어 문자 코드는 16으로 동일하며, 실제 구분은 컨트롤 헤더의 컨트롤 ID로 이루어짐 ("head" = 머리말, "foot" = 꼬리말) /// Control character code is 16 for both, actual distinction is made by control ID in control header ("head" = header, "foot" = footer) pub const HEADER_FOOTER: u8 = 16; /// 각주/미주 / Footnote/endnote /// 제어 문자 코드는 17로 동일하지만, 실제 컨트롤 ID로 구분됨 ("fn " = 각주, "en " = 미주) /// Control character code is 17 for both, but distinguished by control ID ("fn " = footnote, "en " = endnote) pub const FOOTNOTE: u8 = 17; /// 자동번호(각주, 표 등) / Auto number (footnote, table, etc.) pub const AUTO_NUMBER: u8 = 18; /// 페이지 컨트롤(감추기, 새 번호로 시작 등) / Page control (hide, start new number, etc.) pub const PAGE_CONTROL: u8 = 21; /// 책갈피/찾아보기 표식 / Bookmark/find mark pub const BOOKMARK: u8 = 22; /// 덧말/글자 겹침 / Comment overlap pub const COMMENT_OVERLAP: u8 = 23; /// 변환 가능한 제어 문자인지 확인 / Check if control character can be converted /// /// 텍스트로 표현 가능한 제어 문자 (텍스트에 유지됨) / Control characters that can be expressed as text (kept in text) pub fn is_convertible(code: u8) -> bool { matches!( code, Self::TAB \| Self::LINE_BREAK \| Self::PARA_BREAK \| Self::HYPHEN \| Self::BOUND_SPACE \| Self::FIXED_SPACE ) } /// 제어 문자를 텍스트 표현으로 변환 / Convert control character to text representation /// /// 변환 불가능한 경우 None 반환 / Returns None if conversion is not possible pub fn to_text(code: u8) -> Option<&'static str> { match code { Self::TAB => Some("\t"), // 탭 문자 그대로 유지 / Keep tab character as-is Self::LINE_BREAK => Some("\n"), // 한 줄 끝(line break) / Line break Self::PARA_BREAK => Some("\n"), // 문단 끝(para break) - 줄바꿈으로 표현 / Paragraph break - expressed as line break Self::HYPHEN => Some("-"), // 하이픈 / Hyphen Self::BOUND_SPACE => Some(" "), // 묶음 빈칸을 공백으로 변환 / Convert bound space to space Self::FIXED_SPACE => Some(" "), // 고정폭 빈칸을 공백으로 변환 / Convert fixed-width space to space _ => None, } } /// 제어 문자 코드를 이름으로 변환 / Convert control character code to name /// /// # Arguments /// * `code` - 제어 문자 코드 (0-31) / Control character code (0-31) /// /// # Returns /// 제어 문자 상수 이름 (예: "FOOTNOTE", "AUTO_NUMBER") / Control character constant name (e.g., "FOOTNOTE", "AUTO_NUMBER") pub fn to_name(code: u8) -> String { match code { Self::NULL => "NULL".to_string(), Self::RESERVED_1_3_START..=Self::RESERVED_1_3_END => { format!("RESERVED_{}", code) } Self::FIELD_END => "FIELD_END".to_string(), Self::RESERVED_5_7_START..=Self::RESERVED_5_7_END => { format!("RESERVED_{}", code) } Self::TITLE_MARK => "TITLE_MARK".to_string(), Self::TAB => "TAB".to_string(), Self::LINE_BREAK => "LINE_BREAK".to_string(), Self::SHAPE_OBJECT => "SHAPE_OBJECT".to_string(), Self::RESERVED_12 => "RESERVED_12".to_string(), Self::PARA_BREAK => "PARA_BREAK".to_string(), Self::RESERVED_14 => "RESERVED_14".to_string(), Self::HIDDEN_DESC => "HIDDEN_DESC".to_string(), Self::HEADER_FOOTER => "HEADER_FOOTER".to_string(), Self::FOOTNOTE => "FOOTNOTE".to_string(), Self::AUTO_NUMBER => "AUTO_NUMBER".to_string(), Self::RESERVED_19_20_START..=Self::RESERVED_19_20_END => { format!("RESERVED_{}", code) } Self::PAGE_CONTROL => "PAGE_CONTROL".to_string(), Self::BOOKMARK => "BOOKMARK".to_string(), Self::COMMENT_OVERLAP => "COMMENT_OVERLAP".to_string(), Self::HYPHEN => "HYPHEN".to_string(), Self::RESERVED_25_29_START..=Self::RESERVED_25_29_END => { format!("RESERVED_{}", code) } Self::BOUND_SPACE => "BOUND_SPACE".to_string(), Self::FIXED_SPACE => "FIXED_SPACE".to_string(), _ => format!("UNKNOWN_{}", code), } } /// 제어 문자 타입에 따른 크기 반환 (WCHAR 단위) / Get size based on control character type (in WCHAR units) /// /// CHAR: 1 WCHAR (2 bytes) /// INLINE: 8 WCHAR (16 bytes) - 제어 문자 1 + 파라미터 6 /// EXTENDED: 8 WCHAR (16 bytes) - 제어 문자 1 + 포인터 6 #[allow(clippy::if_same_then_else)] pub fn get_size_by_code(code: u8) -> usize { if code <= 31 { // CHAR 타입: 1 WCHAR (2 bytes) // 표 6 참조: 10 (LINE_BREAK), 13 (PARA_BREAK), 24 (HYPHEN), 30 (BOUND_SPACE), 31 (FIXED_SPACE) // 표 6 미명시: 0 (NULL) - CHAR 타입으로 처리 if matches!( code, Self::NULL \| Self::LINE_BREAK \| Self::PARA_BREAK \| Self::HYPHEN \| Self::BOUND_SPACE \| Self::FIXED_SPACE ) { 1 } // INLINE 타입: 8 WCHAR (16 bytes) // 표 6 참조: 4 (FIELD_END), 5-7 (예약), 8 (TITLE_MARK), 9 (TAB), 19-20 (예약) else if matches!( code, Self::FIELD_END \| Self::RESERVED_5_7_START..=Self::RESERVED_5_7_END \| Self::TITLE_MARK \| Self::TAB \| Self::RESERVED_19_20_START..=Self::RESERVED_19_20_END ) { 8 } // EXTENDED 타입: 8 WCHAR (16 bytes) // 표 6 참조: 11-12, 14-18, 21-23 // 표 6 미명시: 1-3 - EXTENDED 타입으로 처리 // INLINE과 동일한 크기(8)이지만 의미적으로 다른 타입임 / Same size (8) as INLINE but semantically different type else { 8 } } else { 1 // 일반 문자 } } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/form_object.rs	crates/hwp-core/src/document/bodytext/form_object.rs	/// FormObject 구조체 / FormObject structure /// /// 구현 상태 / Implementation Status /// - 구현 완료 / Implementation complete /// - 스펙 문서에 상세 구조가 명시되어 있지 않음 / Spec document does not specify detailed structure /// - 테스트 파일(`noori.hwp`)에 FORM_OBJECT 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain FORM_OBJECT records use crate::error::HwpError; use serde::{Deserialize, Serialize}; /// 양식 개체 / Form object #[derive(Debug, Clone, Serialize, Deserialize)] pub struct FormObject { /// Raw 데이터 / Raw data /// 스펙 문서에 상세 구조가 명시되어 있지 않으므로 raw 데이터로 저장합니다. /// Raw data is stored because the spec document does not specify detailed structure. #[serde(skip_serializing_if = "Vec::is_empty")] pub raw_data: Vec<u8>, } impl FormObject { /// FormObject을 바이트 배열에서 파싱합니다. / Parse FormObject from byte array. /// /// # Arguments /// * `data` - FormObject 데이터 / FormObject data /// /// # Returns /// 파싱된 FormObject 구조체 / Parsed FormObject structure /// /// # Note /// 스펙 문서 표 57에는 "양식 개체"로만 언급되어 있고 상세 구조가 명시되어 있지 않습니다. /// 레거시 코드(hwp.js)도 raw 데이터로만 저장하고 있습니다. /// Spec document Table 57 only mentions "Form object" and does not specify detailed structure. /// Legacy code (hwp.js) also stores only raw data. /// /// 테스트 상태 / Testing Status /// 현재 테스트 파일(`noori.hwp`)에 FORM_OBJECT 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 FORM_OBJECT 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain FORM_OBJECT records, so it has not been verified with actual files. /// If an actual HWP file contains FORM_OBJECT records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { Ok(FormObject { raw_data: data.to_vec(), }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/chart_data.rs	crates/hwp-core/src/document/bodytext/chart_data.rs	/// ChartData 구조체 / ChartData structure /// /// 구현 상태 / Implementation Status /// - 구현 완료 / Implementation complete /// - 스펙 문서에 상세 구조가 명시되어 있지 않음 / Spec document does not specify detailed structure /// - 테스트 파일(`noori.hwp`)에 CHART_DATA 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain CHART_DATA records use crate::error::HwpError; use serde::{Deserialize, Serialize}; /// 차트 데이터 / Chart data #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ChartData { /// Raw 데이터 / Raw data /// 스펙 문서에 상세 구조가 명시되어 있지 않으므로 raw 데이터로 저장합니다. /// Raw data is stored because the spec document does not specify detailed structure. #[serde(skip_serializing_if = "Vec::is_empty")] pub raw_data: Vec<u8>, } impl ChartData { /// ChartData를 바이트 배열에서 파싱합니다. / Parse ChartData from byte array. /// /// # Arguments /// * `data` - ChartData 데이터 / ChartData data /// /// # Returns /// 파싱된 ChartData 구조체 / Parsed ChartData structure /// /// # Note /// 스펙 문서 표 57에는 "차트 데이터"로만 언급되어 있고 상세 구조가 명시되어 있지 않습니다. /// 레거시 코드(hwp.js)도 raw 데이터로만 저장하고 있습니다. /// Spec document Table 57 only mentions "Chart data" and does not specify detailed structure. /// Legacy code (hwp.js) also stores only raw data. /// /// 테스트 상태 / Testing Status /// 현재 테스트 파일(`noori.hwp`)에 CHART_DATA 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 CHART_DATA 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain CHART_DATA records, so it has not been verified with actual files. /// If an actual HWP file contains CHART_DATA records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { Ok(ChartData { raw_data: data.to_vec(), }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/shape_component/ole.rs	crates/hwp-core/src/document/bodytext/shape_component/ole.rs	/// ShapeComponentOle 구조체 / ShapeComponentOle structure /// /// 스펙 문서 매핑: 표 118 - OLE 개체 속성 / Spec mapping: Table 118 - OLE shape component attributes /// /// 구현 상태 / Implementation Status /// - 구현 완료 / Implementation complete /// - 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_OLE 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain SHAPE_COMPONENT_OLE records use crate::error::HwpError; use crate::types::{COLORREF, INT32, UINT16, UINT32}; use serde::{Deserialize, Serialize}; /// OLE 개체 / OLE shape component #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ShapeComponentOle { /// 속성 / Attributes (표 119 참조 / See Table 119) pub attributes: OleAttributes, /// 오브젝트 자체의 extent x크기 / Object extent X size pub extent_x: INT32, /// 오브젝트 자체의 extent y크기 / Object extent Y size pub extent_y: INT32, /// 오브젝트가 사용하는 스토리지의 BinData ID / BinData ID of storage used by object pub bindata_id: UINT16, /// 테두리 색 / Border color pub border_color: COLORREF, /// 테두리 두께 / Border width pub border_width: INT32, /// 테두리 속성 / Border attributes (표 87 참조 / See Table 87) pub border_attributes: UINT32, } /// OLE 개체 속성 / OLE shape component attributes #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct OleAttributes { /// Drawing aspect (bit 0-7) /// - DVASPECT_CONTENT = 1 /// - DVASPECT_THUMBNAIL = 2 /// - DVASPECT_ICON = 4 /// - DVASPECT_DOCPRINT = 8 /// 자세한 설명은 MSDN의 MFC COleClientItem::m_nDrawAspect 참고 /// See MSDN MFC COleClientItem::m_nDrawAspect for details pub drawing_aspect: u8, /// TRUE if moniker is assigned (bit 8) /// 자세한 설명은 MSDN의 MFC COleClientItem::m_bMoniker 참고 /// See MSDN MFC COleClientItem::m_bMoniker for details pub has_moniker: bool, /// 베이스라인 (bit 9-15) /// 0은 기본값(85%), 1-101은 0-100%를 나타냄. 현재는 수식만 별도의 베이스라인을 가짐 /// 0 is default (85%), 1-101 represents 0-100%. Currently only equations have separate baseline pub baseline: u8, /// 개체 종류 (bit 16-21) / Object type /// - 0: Unknown /// - 1: Embedded /// - 2: Link /// - 3: Static /// - 4: Equation pub object_type: u8, } impl ShapeComponentOle { /// ShapeComponentOle을 바이트 배열에서 파싱합니다. / Parse ShapeComponentOle from byte array. /// /// # Arguments /// * `data` - ShapeComponentOle 데이터 (OLE 개체 속성 부분만) / ShapeComponentOle data (OLE shape component attributes only) /// /// # Returns /// 파싱된 ShapeComponentOle 구조체 / Parsed ShapeComponentOle structure /// /// # Note /// 스펙 문서 표 117에 따르면 SHAPE_COMPONENT_OLE은 다음 구조를 가집니다: /// - 개체 공통 속성(표 68 참조) - 가변 길이 /// - OLE 개체 속성(표 118 참조) - 24바이트 /// /// 레거시 코드(hwp.js)는 OLE 개체 속성을 파싱하지 않고 있습니다. /// According to spec Table 117, SHAPE_COMPONENT_OLE has the following structure: /// - Object common properties (Table 68) - variable length /// - OLE shape component attributes (Table 118) - 24 bytes /// /// Legacy code (hwp.js) does not parse OLE shape component attributes. /// /// 테스트 상태 / Testing Status /// 현재 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_OLE 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 SHAPE_COMPONENT_OLE 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain SHAPE_COMPONENT_OLE records, so it has not been verified with actual files. /// If an actual HWP file contains SHAPE_COMPONENT_OLE records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // 표 118: OLE 개체 속성은 24바이트 / Table 118: OLE shape component attributes is 24 bytes // UINT16(2) + INT32(4) + INT32(4) + UINT16(2) + COLORREF(4) + INT32(4) + UINT32(4) = 24 bytes if data.len() < 24 { return Err(HwpError::insufficient_data("ShapeComponentOle", 24, data.len())); } let mut offset = 0; // 표 118: 속성 (UINT16, 2바이트) / Table 118: Attributes (UINT16, 2 bytes) let attr_value = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // 표 119: 속성 비트 필드 파싱 / Table 119: Parse attribute bit fields // Note: UINT16 is 16 bits, so bits 16-21 don't exist in this field // 참고: UINT16은 16비트이므로 bit 16-21은 이 필드에 존재하지 않습니다 let drawing_aspect = (attr_value & 0xFF) as u8; // bit 0-7 let has_moniker = (attr_value & 0x100) != 0; // bit 8 let baseline = ((attr_value >> 9) & 0x7F) as u8; // bit 9-15 // object_type is not in UINT16 field, will be read from later data if needed // object_type은 UINT16 필드에 없으며, 필요시 이후 데이터에서 읽습니다 let object_type = 0u8; // Placeholder - may need to read from additional data // 표 118: 오브젝트 자체의 extent x크기 (INT32, 4바이트) / Table 118: Object extent X size (INT32, 4 bytes) let extent_x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 118: 오브젝트 자체의 extent y크기 (INT32, 4바이트) / Table 118: Object extent Y size (INT32, 4 bytes) let extent_y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 118: 오브젝트가 사용하는 스토리지의 BinData ID (UINT16, 2바이트) / Table 118: BinData ID (UINT16, 2 bytes) let bindata_id = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // 표 118: 테두리 색 (COLORREF, 4바이트) / Table 118: Border color (COLORREF, 4 bytes) let border_color_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); let border_color = COLORREF(border_color_value); offset += 4; // 표 118: 테두리 두께 (INT32, 4바이트) / Table 118: Border width (INT32, 4 bytes) let border_width = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 118: 테두리 속성 (UINT32, 4바이트) / Table 118: Border attributes (UINT32, 4 bytes) let border_attributes = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); Ok(ShapeComponentOle { attributes: OleAttributes { drawing_aspect, has_moniker, baseline, object_type, }, extent_x, extent_y, bindata_id, border_color, border_width, border_attributes, }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/shape_component/picture.rs	crates/hwp-core/src/document/bodytext/shape_component/picture.rs	/// ShapeComponentPicture 구조체 / ShapeComponentPicture structure /// /// 스펙 문서 매핑: 표 107 - 그림 개체 속성 / Spec mapping: Table 107 - Picture shape component attributes /// /// 구현 상태 / Implementation Status /// - 구현 완료 / Implementation complete /// - 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_PICTURE 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain SHAPE_COMPONENT_PICTURE records use crate::error::HwpError; use crate::types::{COLORREF, HWPUNIT16, INT32, INT8, UINT16, UINT32}; use serde::{Deserialize, Serialize}; /// 그림 개체 / Picture shape component #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ShapeComponentPicture { /// 테두리 색 / Border color pub border_color: COLORREF, /// 테두리 두께 / Border width pub border_width: INT32, /// 테두리 속성 / Border attributes (표 87 참조 / See Table 87) pub border_attributes: UINT32, /// 이미지의 테두리 사각형의 x 좌표 / X coordinates of image border rectangle (최초 그림 삽입 시 크기 / size at initial picture insertion) pub border_rectangle_x: RectangleCoordinates, /// 이미지의 테두리 사각형의 y 좌표 / Y coordinates of image border rectangle (최초 그림 삽입 시 크기 / size at initial picture insertion) pub border_rectangle_y: RectangleCoordinates, /// 자르기 한 후 사각형 / Cropped rectangle pub crop_rectangle: CropRectangle, /// 안쪽 여백 정보 / Inner padding information (표 77 참조 / See Table 77) pub padding: Padding, /// 그림 정보 / Picture information (표 32 참조 / See Table 32) pub picture_info: PictureInfo, /// 테두리 투명도 / Border opacity pub border_opacity: u8, /// 문서 내 각 개체에 대한 고유 아이디(instance ID) / Unique ID (instance ID) for each object in document pub instance_id: UINT32, /// 그림 효과 정보 / Picture effect information (표 108 참조 / See Table 108) /// 가변 길이이므로 raw 데이터로 저장 / Variable length, stored as raw data #[serde(skip_serializing_if = "Vec::is_empty")] pub effect_data: Vec<u8>, } /// 사각형 좌표 / Rectangle coordinates #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct RectangleCoordinates { /// 왼쪽 / Left pub left: INT32, /// 위쪽 / Top pub top: INT32, /// 오른쪽 / Right pub right: INT32, /// 아래쪽 / Bottom pub bottom: INT32, } /// 자르기 사각형 / Crop rectangle #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct CropRectangle { /// 왼쪽 / Left pub left: INT32, /// 위쪽 / Top pub top: INT32, /// 오른쪽 / Right pub right: INT32, /// 아래쪽 / Bottom pub bottom: INT32, } /// 안쪽 여백 정보 / Inner padding information #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct Padding { /// 왼쪽 여백 / Left padding pub left: HWPUNIT16, /// 오른쪽 여백 / Right padding pub right: HWPUNIT16, /// 위쪽 여백 / Top padding pub top: HWPUNIT16, /// 아래쪽 여백 / Bottom padding pub bottom: HWPUNIT16, } /// 그림 정보 / Picture information #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct PictureInfo { /// 밝기 / Brightness pub brightness: INT8, /// 명암 / Contrast pub contrast: INT8, /// 그림 효과 / Picture effect /// - 0: REAL_PIC /// - 1: GRAY_SCALE /// - 2: BLACK_WHITE /// - 4: PATTERN8x8 pub effect: u8, /// BinItem의 아이디 참조값 / BinItem ID reference pub bindata_id: UINT16, } impl ShapeComponentPicture { /// ShapeComponentPicture을 바이트 배열에서 파싱합니다. / Parse ShapeComponentPicture from byte array. /// /// # Arguments /// * `data` - ShapeComponentPicture 데이터 (그림 개체 속성 부분만) / ShapeComponentPicture data (picture shape component attributes only) /// /// # Returns /// 파싱된 ShapeComponentPicture 구조체 / Parsed ShapeComponentPicture structure /// /// # Note /// 스펙 문서 표 106에 따르면 SHAPE_COMPONENT_PICTURE은 다음 구조를 가집니다: /// - 개체 공통 속성(표 68 참조) - 가변 길이 /// - 개체 요소 공통 속성(표 83 참조) - 가변 길이 /// - 그림 개체 속성(표 107 참조) - 가변 길이 (78 + n 바이트) /// /// 레거시 코드(hwp.js)는 그림 개체 속성의 일부만 파싱하고 있습니다. /// According to spec Table 106, SHAPE_COMPONENT_PICTURE has the following structure: /// - Object common properties (Table 68) - variable length /// - Object element common properties (Table 83) - variable length /// - Picture shape component attributes (Table 107) - variable length (78 + n bytes) /// /// Legacy code (hwp.js) only parses part of picture shape component attributes. /// /// 테스트 상태 / Testing Status /// 현재 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_PICTURE 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 SHAPE_COMPONENT_PICTURE 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain SHAPE_COMPONENT_PICTURE records, so it has not been verified with actual files. /// If an actual HWP file contains SHAPE_COMPONENT_PICTURE records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { let mut offset = 0; // 그림 개체 속성(표 107) 파싱 시작 / Start parsing picture shape component attributes (Table 107) // 최소 78바이트 필요 (고정 부분) / Need at least 78 bytes (fixed part) if data.len() < 78 { return Err(HwpError::insufficient_data("ShapeComponentPicture", 78, data.len())); } // 표 107: 테두리 색 (COLORREF, 4바이트) / Table 107: Border color (COLORREF, 4 bytes) let border_color_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); let border_color = COLORREF(border_color_value); offset += 4; // 표 107: 테두리 두께 (INT32, 4바이트) / Table 107: Border width (INT32, 4 bytes) let border_width = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 107: 테두리 속성 (UINT32, 4바이트) / Table 107: Border attributes (UINT32, 4 bytes) let border_attributes = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 107: 이미지의 테두리 사각형의 x 좌표 (INT32 array[4], 16바이트) / Table 107: X coordinates of image border rectangle (INT32 array[4], 16 bytes) let border_x_left = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let border_x_top = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let border_x_right = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let border_x_bottom = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 107: 이미지의 테두리 사각형의 y 좌표 (INT32 array[4], 16바이트) / Table 107: Y coordinates of image border rectangle (INT32 array[4], 16 bytes) let border_y_left = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let border_y_top = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let border_y_right = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let border_y_bottom = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 107: 자르기 한 후 사각형의 left (INT32, 4바이트) / Table 107: Cropped rectangle left (INT32, 4 bytes) let crop_left = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 107: 자르기 한 후 사각형의 top (INT32, 4바이트) / Table 107: Cropped rectangle top (INT32, 4 bytes) let crop_top = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 107: 자르기 한 후 사각형의 right (INT32, 4바이트) / Table 107: Cropped rectangle right (INT32, 4 bytes) let crop_right = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 107: 자르기 한 후 사각형의 bottom (INT32, 4바이트) / Table 107: Cropped rectangle bottom (INT32, 4 bytes) let crop_bottom = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 107: 안쪽 여백 정보 (표 77 참조, 8바이트) / Table 107: Inner padding information (Table 77, 8 bytes) let padding_left = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let padding_right = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let padding_top = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let padding_bottom = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // 표 107: 그림 정보 (표 32 참조, 5바이트) / Table 107: Picture information (Table 32, 5 bytes) let brightness = data[offset] as i8; offset += 1; let contrast = data[offset] as i8; offset += 1; let effect = data[offset]; offset += 1; let bindata_id = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // 표 107: 테두리 투명도 (BYTE, 1바이트) / Table 107: Border opacity (BYTE, 1 byte) let border_opacity = data[offset]; offset += 1; // 표 107: 문서 내 각 개체에 대한 고유 아이디(instance ID) (UINT32, 4바이트) / Table 107: Instance ID (UINT32, 4 bytes) let instance_id = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 107: 그림 효과 정보 (표 108 참조, 가변 길이) / Table 107: Picture effect information (Table 108, variable length) let effect_data = if offset < data.len() { data[offset..].to_vec() } else { Vec::new() }; Ok(ShapeComponentPicture { border_color, border_width, border_attributes, border_rectangle_x: RectangleCoordinates { left: border_x_left, top: border_x_top, right: border_x_right, bottom: border_x_bottom, }, border_rectangle_y: RectangleCoordinates { left: border_y_left, top: border_y_top, right: border_y_right, bottom: border_y_bottom, }, crop_rectangle: CropRectangle { left: crop_left, top: crop_top, right: crop_right, bottom: crop_bottom, }, padding: Padding { left: padding_left, right: padding_right, top: padding_top, bottom: padding_bottom, }, picture_info: PictureInfo { brightness, contrast, effect, bindata_id, }, border_opacity, instance_id, effect_data, }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/shape_component/unknown.rs	crates/hwp-core/src/document/bodytext/shape_component/unknown.rs	/// ShapeComponentUnknown 구조체 / ShapeComponentUnknown structure /// /// 스펙 문서 매핑: 표 57 - Unknown (36바이트) / Spec mapping: Table 57 - Unknown (36 bytes) /// /// 구현 상태 / Implementation Status /// - 구현 완료 / Implementation complete /// - 스펙 문서에 상세 구조가 명시되어 있지 않음 / Spec document does not specify detailed structure /// - 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_UNKNOWN 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain SHAPE_COMPONENT_UNKNOWN records use crate::error::HwpError; use serde::{Deserialize, Serialize}; /// Unknown 개체 / Unknown shape component #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ShapeComponentUnknown { /// Raw 데이터 / Raw data /// 스펙 문서에 상세 구조가 명시되어 있지 않으므로 raw 데이터로 저장합니다. /// 스펙 문서 표 57에는 36바이트로 정의되어 있습니다. /// Raw data is stored because the spec document does not specify detailed structure. /// Spec document Table 57 defines it as 36 bytes. #[serde(skip_serializing_if = "Vec::is_empty")] pub raw_data: Vec<u8>, } impl ShapeComponentUnknown { /// ShapeComponentUnknown을 바이트 배열에서 파싱합니다. / Parse ShapeComponentUnknown from byte array. /// /// # Arguments /// * `data` - ShapeComponentUnknown 데이터 / ShapeComponentUnknown data /// /// # Returns /// 파싱된 ShapeComponentUnknown 구조체 / Parsed ShapeComponentUnknown structure /// /// # Note /// 스펙 문서 표 57에는 "Unknown"으로만 언급되어 있고 상세 구조가 명시되어 있지 않습니다. /// 스펙 문서에는 36바이트로 정의되어 있지만, 실제 파일에서는 다를 수 있습니다. /// 레거시 코드(hwp.js)도 raw 데이터로만 저장하고 있습니다. /// Spec document Table 57 only mentions "Unknown" and does not specify detailed structure. /// Spec document defines it as 36 bytes, but actual files may differ. /// Legacy code (hwp.js) also stores only raw data. /// /// 테스트 상태 / Testing Status /// 현재 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_UNKNOWN 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 SHAPE_COMPONENT_UNKNOWN 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain SHAPE_COMPONENT_UNKNOWN records, so it has not been verified with actual files. /// If an actual HWP file contains SHAPE_COMPONENT_UNKNOWN records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { Ok(ShapeComponentUnknown { raw_data: data.to_vec(), }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/shape_component/textart.rs	crates/hwp-core/src/document/bodytext/shape_component/textart.rs	/// ShapeComponentTextArt 구조체 / ShapeComponentTextArt structure /// /// 구현 상태 / Implementation Status /// - 구현 완료 / Implementation complete /// - 스펙 문서에 상세 구조가 명시되어 있지 않음 / Spec document does not specify detailed structure /// - 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_TEXTART 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain SHAPE_COMPONENT_TEXTART records use crate::error::HwpError; use serde::{Deserialize, Serialize}; /// 글맵시 개체 / Text art shape component #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ShapeComponentTextArt { /// Raw 데이터 / Raw data /// 스펙 문서에 상세 구조가 명시되어 있지 않으므로 raw 데이터로 저장합니다. /// Raw data is stored because the spec document does not specify detailed structure. #[serde(skip_serializing_if = "Vec::is_empty")] pub raw_data: Vec<u8>, } impl ShapeComponentTextArt { /// ShapeComponentTextArt을 바이트 배열에서 파싱합니다. / Parse ShapeComponentTextArt from byte array. /// /// # Arguments /// * `data` - ShapeComponentTextArt 데이터 / ShapeComponentTextArt data /// /// # Returns /// 파싱된 ShapeComponentTextArt 구조체 / Parsed ShapeComponentTextArt structure /// /// # Note /// 스펙 문서 표 57에는 "글맵시"로만 언급되어 있고 상세 구조가 명시되어 있지 않습니다. /// 레거시 코드(hwp.js)도 raw 데이터로만 저장하고 있습니다. /// Spec document Table 57 only mentions "Text art" and does not specify detailed structure. /// Legacy code (hwp.js) also stores only raw data. /// /// 테스트 상태 / Testing Status /// 현재 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_TEXTART 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 SHAPE_COMPONENT_TEXTART 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain SHAPE_COMPONENT_TEXTART records, so it has not been verified with actual files. /// If an actual HWP file contains SHAPE_COMPONENT_TEXTART records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { Ok(ShapeComponentTextArt { raw_data: data.to_vec(), }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/shape_component/container.rs	crates/hwp-core/src/document/bodytext/shape_component/container.rs	/// ShapeComponentContainer 구조체 / ShapeComponentContainer structure /// /// 스펙 문서 매핑: 표 121 - 묶음 개체 속성 / Spec mapping: Table 121 - Container shape component attributes /// /// 구현 상태 / Implementation Status /// - 구현 완료 / Implementation complete /// - 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_CONTAINER 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain SHAPE_COMPONENT_CONTAINER records use crate::error::HwpError; use crate::types::{UINT16, UINT32}; use serde::{Deserialize, Serialize}; /// 묶음 개체 / Container shape component #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ShapeComponentContainer { /// 개체의 개수 / Number of objects pub object_count: UINT16, /// 개체의 컨트롤 ID 배열 / Control ID array of objects pub control_ids: Vec<UINT32>, } impl ShapeComponentContainer { /// ShapeComponentContainer을 바이트 배열에서 파싱합니다. / Parse ShapeComponentContainer from byte array. /// /// # Arguments /// * `data` - ShapeComponentContainer 데이터 (묶음 개체 속성 부분만) / ShapeComponentContainer data (container shape component attributes only) /// /// # Returns /// 파싱된 ShapeComponentContainer 구조체 / Parsed ShapeComponentContainer structure /// /// # Note /// 스펙 문서 표 120에 따르면 SHAPE_COMPONENT_CONTAINER은 다음 구조를 가집니다: /// - 개체 공통 속성(표 68 참조) - 가변 길이 /// - 묶음 개체 속성(표 121 참조) - 가변 길이 (2 + 4×n 바이트) /// - 개체 속성 x 묶음 개체의 갯수 - 가변 길이 /// /// 레거시 코드(hwp.js)는 묶음 개체 속성을 파싱하지 않고 있습니다. /// According to spec Table 120, SHAPE_COMPONENT_CONTAINER has the following structure: /// - Object common properties (Table 68) - variable length /// - Container shape component attributes (Table 121) - variable length (2 + 4×n bytes) /// - Object properties × number of container objects - variable length /// /// Legacy code (hwp.js) does not parse container shape component attributes. /// /// 테스트 상태 / Testing Status /// 현재 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_CONTAINER 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 SHAPE_COMPONENT_CONTAINER 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain SHAPE_COMPONENT_CONTAINER records, so it has not been verified with actual files. /// If an actual HWP file contains SHAPE_COMPONENT_CONTAINER records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // 최소 2바이트 필요 (개체의 개수) / Need at least 2 bytes (object count) if data.len() < 2 { return Err(HwpError::insufficient_data("ShapeComponentContainer", 2, data.len())); } let mut offset = 0; // 표 121: 개체의 개수 (WORD, 2바이트) / Table 121: Number of objects (WORD, 2 bytes) let object_count = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let object_count_usize = object_count as usize; // 필요한 바이트 수 계산 / Calculate required bytes // WORD(2) + UINT32 array[n](4×n) = 2 + 4×n let required_bytes = 2 + 4 * object_count_usize; if data.len() < required_bytes { return Err(HwpError::InsufficientData { field: format!("ShapeComponentContainer (object_count={})", object_count_usize), expected: required_bytes, actual: data.len(), }); } // 표 121: 개체의 컨트롤 ID 배열 (UINT32 array[n], 4×n 바이트) / Table 121: Control ID array (UINT32 array[n], 4×n bytes) let mut control_ids = Vec::with_capacity(object_count_usize); for _ in 0..object_count_usize { let control_id = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); control_ids.push(control_id); offset += 4; } Ok(ShapeComponentContainer { object_count, control_ids, }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/shape_component/rectangle.rs	crates/hwp-core/src/document/bodytext/shape_component/rectangle.rs	/// ShapeComponentRectangle 구조체 / ShapeComponentRectangle structure /// /// 스펙 문서 매핑: 표 94 - 사각형 개체 속성 / Spec mapping: Table 94 - Rectangle shape component attributes /// /// 구현 상태 / Implementation Status /// - 구현 완료 / Implementation complete /// - 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_RECTANGLE 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain SHAPE_COMPONENT_RECTANGLE records use crate::error::HwpError; use crate::types::INT32; use serde::{Deserialize, Serialize}; /// 사각형 개체 / Rectangle shape component #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ShapeComponentRectangle { /// 사각형 모서리 곡률(%) / Rectangle corner curvature (%) /// 직각은 0, 둥근 모양은 20, 반원은 50, 그 외는 적당한 값을 % 단위로 사용한다. /// Right angle is 0, rounded shape is 20, semicircle is 50, others use appropriate values in %. pub corner_curvature: u8, /// 사각형의 좌표(x) / Rectangle coordinates (x) pub x_coordinates: RectangleCoordinates, /// 사각형의 좌표(y) / Rectangle coordinates (y) pub y_coordinates: RectangleCoordinates, } /// 사각형 좌표 / Rectangle coordinates #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct RectangleCoordinates { /// 상단 / Top pub top: INT32, /// 오른쪽 / Right pub right: INT32, /// 하단 / Bottom pub bottom: INT32, /// 왼쪽 / Left pub left: INT32, } impl ShapeComponentRectangle { /// ShapeComponentRectangle을 바이트 배열에서 파싱합니다. / Parse ShapeComponentRectangle from byte array. /// /// # Arguments /// * `data` - ShapeComponentRectangle 데이터 (사각형 개체 속성 부분만) / ShapeComponentRectangle data (rectangle shape component attributes only) /// /// # Returns /// 파싱된 ShapeComponentRectangle 구조체 / Parsed ShapeComponentRectangle structure /// /// # Note /// 스펙 문서 표 93에 따르면 SHAPE_COMPONENT_RECTANGLE은 다음 구조를 가집니다: /// - 개체 공통 속성(표 68 참조) - 가변 길이 /// - 그리기 개체 공통 속성(표 81 참조) - 가변 길이 /// - 사각형 개체 속성(표 94 참조) - 33바이트 /// /// 레거시 코드(hwp.js)는 사각형 개체 속성 부분만 파싱하고 있습니다. /// According to spec Table 93, SHAPE_COMPONENT_RECTANGLE has the following structure: /// - Object common properties (Table 68) - variable length /// - Drawing object common properties (Table 81) - variable length /// - Rectangle shape component attributes (Table 94) - 33 bytes /// /// Legacy code (hwp.js) only parses the rectangle shape component attributes part. /// /// 테스트 상태 / Testing Status /// 현재 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_RECTANGLE 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 SHAPE_COMPONENT_RECTANGLE 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain SHAPE_COMPONENT_RECTANGLE records, so it has not been verified with actual files. /// If an actual HWP file contains SHAPE_COMPONENT_RECTANGLE records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // 표 94: 사각형 개체 속성은 33바이트 / Table 94: Rectangle shape component attributes is 33 bytes // BYTE(1) + INT32 array[4](16) + INT32 array[4](16) = 33 bytes if data.len() < 33 { return Err(HwpError::insufficient_data("ShapeComponentRectangle", 33, data.len())); } let mut offset = 0; // 표 94: 사각형 모서리 곡률(%) (BYTE, 1바이트) / Table 94: Rectangle corner curvature (%) (BYTE, 1 byte) let corner_curvature = data[offset]; offset += 1; // 표 94: 사각형의 좌표(x) (INT32 array[4], 16바이트) / Table 94: Rectangle coordinates (x) (INT32 array[4], 16 bytes) let x_top = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let x_right = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let x_bottom = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let x_left = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 94: 사각형의 좌표(y) (INT32 array[4], 16바이트) / Table 94: Rectangle coordinates (y) (INT32 array[4], 16 bytes) let y_top = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let y_right = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let y_bottom = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let y_left = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); Ok(ShapeComponentRectangle { corner_curvature, x_coordinates: RectangleCoordinates { top: x_top, right: x_right, bottom: x_bottom, left: x_left, }, y_coordinates: RectangleCoordinates { top: y_top, right: y_right, bottom: y_bottom, left: y_left, }, }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/shape_component/curve.rs	crates/hwp-core/src/document/bodytext/shape_component/curve.rs	/// ShapeComponentCurve 구조체 / ShapeComponentCurve structure /// /// 스펙 문서 매핑: 표 103 - 곡선 개체 속성 / Spec mapping: Table 103 - Curve shape component attributes /// /// 구현 상태 / Implementation Status /// - 구현 완료 / Implementation complete /// - 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_CURVE 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain SHAPE_COMPONENT_CURVE records use crate::error::HwpError; use crate::types::{INT16, INT32}; use serde::{Deserialize, Serialize}; /// 곡선 개체 / Curve shape component #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ShapeComponentCurve { /// 점의 개수 / Count of points pub point_count: INT16, /// X 좌표 배열 / X coordinates array pub x_coordinates: Vec<INT32>, /// Y 좌표 배열 / Y coordinates array pub y_coordinates: Vec<INT32>, /// 세그먼트 타입 배열 / Segment type array /// 0: line, 1: curve pub segment_types: Vec<u8>, } impl ShapeComponentCurve { /// ShapeComponentCurve을 바이트 배열에서 파싱합니다. / Parse ShapeComponentCurve from byte array. /// /// # Arguments /// * `data` - ShapeComponentCurve 데이터 (곡선 개체 속성 부분만) / ShapeComponentCurve data (curve shape component attributes only) /// /// # Returns /// 파싱된 ShapeComponentCurve 구조체 / Parsed ShapeComponentCurve structure /// /// # Note /// 스펙 문서 표 102에 따르면 SHAPE_COMPONENT_CURVE은 다음 구조를 가집니다: /// - 개체 공통 속성(표 68 참조) - 가변 길이 /// - 그리기 개체 공통 속성(표 81 참조) - 가변 길이 /// - 곡선 개체 속성(표 103 참조) - 가변 길이 (2 + 2(4×cnt) + cnt-1 바이트) /// /// 레거시 코드(hwp.js)는 곡선 개체 속성 부분만 파싱하고 있습니다. /// According to spec Table 102, SHAPE_COMPONENT_CURVE has the following structure: /// - Object common properties (Table 68) - variable length /// - Drawing object common properties (Table 81) - variable length /// - Curve shape component attributes (Table 103) - variable length (2 + 2(4×cnt) + cnt-1 bytes) /// /// Legacy code (hwp.js) only parses the curve shape component attributes part. /// /// 테스트 상태 / Testing Status /// 현재 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_CURVE 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 SHAPE_COMPONENT_CURVE 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain SHAPE_COMPONENT_CURVE records, so it has not been verified with actual files. /// If an actual HWP file contains SHAPE_COMPONENT_CURVE records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // 최소 2바이트 필요 (점의 개수) / Need at least 2 bytes (point count) if data.len() < 2 { return Err(HwpError::insufficient_data("ShapeComponentCurve", 2, data.len())); } let mut offset = 0; // 표 103: 점의 개수 (INT16, 2바이트) / Table 103: Count of points (INT16, 2 bytes) let point_count = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // 점의 개수가 음수이거나 0이면 오류 / If point count is negative or zero, error if point_count <= 0 { return Err(HwpError::UnexpectedValue { field: "ShapeComponentCurve point_count".to_string(), expected: "positive number".to_string(), found: point_count.to_string(), }); } let point_count_usize = point_count as usize; // 필요한 바이트 수 계산 / Calculate required bytes // INT16(2) + INT32 array[cnt](4×cnt) + INT32 array[cnt](4×cnt) + BYTE array[cnt-1](cnt-1) = 2 + 8×cnt + cnt-1 let required_bytes = 2 + 8 * point_count_usize + point_count_usize - 1; if data.len() < required_bytes { return Err(HwpError::InsufficientData { field: format!("ShapeComponentCurve (point_count={})", point_count_usize), expected: required_bytes, actual: data.len(), }); } // 표 103: X 좌표 배열 (INT32 array[cnt], 4×cnt 바이트) / Table 103: X coordinates array (INT32 array[cnt], 4×cnt bytes) let mut x_coordinates = Vec::with_capacity(point_count_usize); for _ in 0..point_count_usize { let x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); x_coordinates.push(x); offset += 4; } // 표 103: Y 좌표 배열 (INT32 array[cnt], 4×cnt 바이트) / Table 103: Y coordinates array (INT32 array[cnt], 4×cnt bytes) let mut y_coordinates = Vec::with_capacity(point_count_usize); for _ in 0..point_count_usize { let y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); y_coordinates.push(y); offset += 4; } // 표 103: 세그먼트 타입 배열 (BYTE array[cnt-1], cnt-1 바이트) / Table 103: Segment type array (BYTE array[cnt-1], cnt-1 bytes) let mut segment_types = Vec::with_capacity(point_count_usize - 1); for _ in 0..(point_count_usize - 1) { segment_types.push(data[offset]); offset += 1; } Ok(ShapeComponentCurve { point_count, x_coordinates, y_coordinates, segment_types, }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/shape_component/polygon.rs	crates/hwp-core/src/document/bodytext/shape_component/polygon.rs	/// ShapeComponentPolygon 구조체 / ShapeComponentPolygon structure /// /// 스펙 문서 매핑: 표 99 - 다각형 개체 속성 / Spec mapping: Table 99 - Polygon shape component attributes /// /// 구현 상태 / Implementation Status /// - 구현 완료 / Implementation complete /// - 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_POLYGON 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain SHAPE_COMPONENT_POLYGON records use crate::error::HwpError; use crate::types::{INT16, INT32}; use serde::{Deserialize, Serialize}; /// 다각형 개체 / Polygon shape component #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ShapeComponentPolygon { /// 점의 개수 / Count of points pub point_count: INT16, /// X 좌표 배열 / X coordinates array pub x_coordinates: Vec<INT32>, /// Y 좌표 배열 / Y coordinates array pub y_coordinates: Vec<INT32>, } impl ShapeComponentPolygon { /// ShapeComponentPolygon을 바이트 배열에서 파싱합니다. / Parse ShapeComponentPolygon from byte array. /// /// # Arguments /// * `data` - ShapeComponentPolygon 데이터 (다각형 개체 속성 부분만) / ShapeComponentPolygon data (polygon shape component attributes only) /// /// # Returns /// 파싱된 ShapeComponentPolygon 구조체 / Parsed ShapeComponentPolygon structure /// /// # Note /// 스펙 문서 표 98에 따르면 SHAPE_COMPONENT_POLYGON은 다음 구조를 가집니다: /// - 개체 공통 속성(표 68 참조) - 가변 길이 /// - 그리기 개체 공통 속성(표 81 참조) - 가변 길이 /// - 다각형 개체 속성(표 99 참조) - 가변 길이 (2 + 2(4×cnt) 바이트) /// /// 레거시 코드(hwp.js)는 다각형 개체 속성 부분만 파싱하고 있습니다. /// According to spec Table 98, SHAPE_COMPONENT_POLYGON has the following structure: /// - Object common properties (Table 68) - variable length /// - Drawing object common properties (Table 81) - variable length /// - Polygon shape component attributes (Table 99) - variable length (2 + 2(4×cnt) bytes) /// /// Legacy code (hwp.js) only parses the polygon shape component attributes part. /// /// 테스트 상태 / Testing Status /// 현재 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_POLYGON 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 SHAPE_COMPONENT_POLYGON 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain SHAPE_COMPONENT_POLYGON records, so it has not been verified with actual files. /// If an actual HWP file contains SHAPE_COMPONENT_POLYGON records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // 최소 2바이트 필요 (점의 개수) / Need at least 2 bytes (point count) if data.len() < 2 { return Err(HwpError::insufficient_data("ShapeComponentPolygon", 2, data.len())); } let mut offset = 0; // 표 99: 점의 개수 (INT16, 2바이트) / Table 99: Count of points (INT16, 2 bytes) let point_count = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // 점의 개수가 음수이거나 0이면 오류 / If point count is negative or zero, error if point_count <= 0 { return Err(HwpError::UnexpectedValue { field: "ShapeComponentPolygon point_count".to_string(), expected: "positive number".to_string(), found: point_count.to_string(), }); } let point_count_usize = point_count as usize; // 필요한 바이트 수 계산 / Calculate required bytes // INT16(2) + INT32 array[cnt](4×cnt) + INT32 array[cnt](4×cnt) = 2 + 8×cnt let required_bytes = 2 + 8 * point_count_usize; if data.len() < required_bytes { return Err(HwpError::InsufficientData { field: format!("ShapeComponentPolygon (point_count={})", point_count_usize), expected: required_bytes, actual: data.len(), }); } // 표 99: X 좌표 배열 (INT32 array[cnt], 4×cnt 바이트) / Table 99: X coordinates array (INT32 array[cnt], 4×cnt bytes) let mut x_coordinates = Vec::with_capacity(point_count_usize); for _ in 0..point_count_usize { let x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); x_coordinates.push(x); offset += 4; } // 표 99: Y 좌표 배열 (INT32 array[cnt], 4×cnt 바이트) / Table 99: Y coordinates array (INT32 array[cnt], 4×cnt bytes) let mut y_coordinates = Vec::with_capacity(point_count_usize); for _ in 0..point_count_usize { let y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); y_coordinates.push(y); offset += 4; } Ok(ShapeComponentPolygon { point_count, x_coordinates, y_coordinates, }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/shape_component/mod.rs	crates/hwp-core/src/document/bodytext/shape_component/mod.rs	mod common; mod arc; mod container; mod curve; mod ellipse; mod line; mod ole; mod picture; mod polygon; mod rectangle; mod textart; mod unknown; pub use common::ShapeComponent; pub use arc::ShapeComponentArc; pub use container::ShapeComponentContainer; pub use curve::ShapeComponentCurve; pub use ellipse::ShapeComponentEllipse; pub use line::ShapeComponentLine; pub use ole::ShapeComponentOle; pub use picture::ShapeComponentPicture; pub use polygon::ShapeComponentPolygon; pub use rectangle::ShapeComponentRectangle; pub use textart::ShapeComponentTextArt; pub use unknown::ShapeComponentUnknown;	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/shape_component/common.rs	crates/hwp-core/src/document/bodytext/shape_component/common.rs	/// ShapeComponent 구조체 / ShapeComponent structure /// /// 스펙 문서 매핑: 표 82, 83 - 개체 요소 속성 / Spec mapping: Table 82, 83 - Shape component attributes use crate::error::HwpError; use crate::types::{HWPUNIT16, INT32, UINT16, UINT32}; use serde::{Deserialize, Serialize}; /// 개체 요소 / Shape component #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ShapeComponent { /// 개체 컨트롤 ID / Object control ID pub object_control_id: String, /// 개체 컨트롤 ID 2 (GenShapeObject일 경우 id가 두 번 기록됨) / Object control ID 2 (for GenShapeObject, ID is recorded twice) #[serde(skip_serializing_if = "Option::is_none")] pub object_control_id2: Option<String>, /// 개체가 속한 그룹 내에서의 offset / Offset within group pub group_offset: GroupOffset, /// 몇 번이나 그룹 되었는지 / Number of times grouped pub group_count: UINT16, /// 개체 요소의 local file version / Local file version pub local_version: UINT16, /// 개체 생성 시 초기 폭 / Initial width pub initial_width: UINT32, /// 개체 생성 시 초기 높이 / Initial height pub initial_height: UINT32, /// 개체의 현재 폭 / Current width pub width: UINT32, /// 개체의 현재 높이 / Current height pub height: UINT32, /// 속성 / Attributes pub attributes: ShapeComponentAttributes, /// 회전각 / Rotation angle pub rotation_angle: HWPUNIT16, /// 회전 중심 좌표 / Rotation center coordinates pub rotation_center: RotationCenter, /// Rendering 정보 / Rendering information pub rendering: RenderingInfo, } /// 개체가 속한 그룹 내에서의 offset / Offset within group #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct GroupOffset { /// X offset pub x: INT32, /// Y offset pub y: INT32, } /// 개체 요소 속성 / Shape component attributes #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum ShapeComponentAttributes { /// 수평 뒤집기 / Horizontal flip HorizontalFlip, /// 수직 뒤집기 / Vertical flip VerticalFlip, } /// 회전 중심 좌표 / Rotation center coordinates #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct RotationCenter { /// X 좌표(개체 좌표계) / X coordinate (object coordinate system) pub x: INT32, /// Y 좌표(개체 좌표계) / Y coordinate (object coordinate system) pub y: INT32, } /// Rendering 정보 / Rendering information #[derive(Debug, Clone, Serialize, Deserialize)] pub struct RenderingInfo { /// scale matrix와 rotation matrix쌍의 개수 / Number of scale matrix and rotation matrix pairs pub matrix_count: UINT16, /// translation matrix / Translation matrix pub translation_matrix: Matrix, /// scale matrix/rotation matrix sequence / Scale matrix/rotation matrix sequence pub matrix_sequence: Vec<MatrixPair>, } /// Matrix 정보 / Matrix information /// 3X3 matrix의 원소 (마지막 줄은 항상 0, 0, 1이므로 저장되지 않음) /// Elements of 3X3 matrix (last row is always 0, 0, 1 so not stored) #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct Matrix { /// 3X2 matrix의 원소 (6개 double 값, 48바이트) / Elements of 3X2 matrix (6 double values, 48 bytes) pub elements: [f64; 6], } /// Matrix 쌍 / Matrix pair #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct MatrixPair { /// Scale matrix pub scale: Matrix, /// Rotation matrix pub rotation: Matrix, } impl ShapeComponent { /// ShapeComponent를 바이트 배열에서 파싱합니다. / Parse ShapeComponent from byte array. /// /// # Arguments /// * `data` - ShapeComponent 데이터 / ShapeComponent data /// /// # Returns /// 파싱된 ShapeComponent 구조체 / Parsed ShapeComponent structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 4 { return Err(HwpError::insufficient_data("ShapeComponent", 4, data.len())); } let mut offset = 0; // 표 82: 개체 컨트롤 ID (UINT32, 4바이트) / Table 82: Object control ID (UINT32, 4 bytes) let ctrl_id_value1 = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // ctrl_id를 문자열로 변환 (4바이트 ASCII) / Convert ctrl_id to string (4-byte ASCII) let object_control_id = String::from_utf8_lossy(&data[offset - 4..offset]) .trim_end_matches('\0') .trim_end_matches(' ') .to_string(); // 스펙 문서 표 82 주석: "GenShapeObject일 경우 id가 두 번 기록됨" // 하지만 실제 파일에서는 모든 SHAPE_COMPONENT에서 두 번째 ID가 존재함 // 레거시 코드도 항상 두 번째 ID를 읽고 있음 // Spec Table 82 comment: "For GenShapeObject, ID is recorded twice" // However, in actual files, second ID exists in all SHAPE_COMPONENT records // Legacy code also always reads the second ID let object_control_id2 = if data.len() >= offset + 4 { // 두 번째 ID 읽기 / Read second ID let ctrl_id_value2 = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; Some( String::from_utf8_lossy(&data[offset - 4..offset]) .trim_end_matches('\0') .trim_end_matches(' ') .to_string(), ) } else { None }; // 표 83: 개체 요소 속성 / Table 83: Shape component attributes if data.len() < offset + 42 { return Err(HwpError::InsufficientData { field: format!("ShapeComponent attributes at offset {}", offset), expected: offset + 42, actual: data.len(), }); } // INT32: 개체가 속한 그룹 내에서의 X offset / INT32: X offset within group let group_x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // INT32: 개체가 속한 그룹 내에서의 Y offset / INT32: Y offset within group let group_y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // WORD: 몇 번이나 그룹 되었는지 / WORD: Number of times grouped let group_count = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // WORD: 개체 요소의 local file version / WORD: Local file version let local_version = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT32: 개체 생성 시 초기 폭 / UINT32: Initial width let initial_width = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // UINT32: 개체 생성 시 초기 높이 / UINT32: Initial height let initial_height = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // UINT32: 개체의 현재 폭 / UINT32: Current width let width = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // UINT32: 개체의 현재 높이 / UINT32: Current height let height = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // UINT32: 속성 / UINT32: Attributes // 0: horz flip, 1: vert flip let attribute_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let attributes = if attribute_value == 0 { ShapeComponentAttributes::HorizontalFlip } else { ShapeComponentAttributes::VerticalFlip }; // HWPUNIT16: 회전각 / HWPUNIT16: Rotation angle let rotation_angle = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // INT32: 회전 중심의 x 좌표(개체 좌표계) / INT32: Rotation center x coordinate (object coordinate system) let rotation_center_x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // INT32: 회전 중심의 y 좌표(개체 좌표계) / INT32: Rotation center y coordinate (object coordinate system) let rotation_center_y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 84: Rendering 정보 / Table 84: Rendering information if data.len() < offset + 2 { return Err(HwpError::insufficient_data( "ShapeComponent rendering info", 2, data.len() - offset, )); } // WORD: scale matrix와 rotation matrix쌍의 개수 / WORD: Number of scale matrix and rotation matrix pairs let matrix_count = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // BYTE stream (48바이트): translation matrix / BYTE stream (48 bytes): Translation matrix if data.len() < offset + 48 { return Err(HwpError::InsufficientData { field: format!("ShapeComponent translation matrix at offset {}", offset), expected: offset + 48, actual: data.len(), }); } let translation_matrix = parse_matrix(&data[offset..offset + 48]).map_err(\|e\| HwpError::from(e))?; offset += 48; // BYTE stream (cnt×48×2): scale matrix/rotation matrix sequence let matrix_sequence_size = matrix_count as usize * 48 * 2; if data.len() < offset + matrix_sequence_size { return Err(HwpError::InsufficientData { field: format!("ShapeComponent matrix sequence at offset {}", offset), expected: offset + matrix_sequence_size, actual: data.len(), }); } let mut matrix_sequence = Vec::new(); for i in 0..matrix_count as usize { let seq_offset = offset + (i * 48 * 2); let scale_matrix = parse_matrix(&data[seq_offset..seq_offset + 48]).map_err(\|e\| HwpError::from(e))?; let rotation_matrix = parse_matrix(&data[seq_offset + 48..seq_offset + 96]) .map_err(\|e\| HwpError::from(e))?; matrix_sequence.push(MatrixPair { scale: scale_matrix, rotation: rotation_matrix, }); } let _ = offset + matrix_sequence_size; // offset은 더 이상 사용되지 않음 / offset is no longer used Ok(ShapeComponent { object_control_id, object_control_id2, group_offset: GroupOffset { x: group_x, y: group_y, }, group_count, local_version, initial_width, initial_height, width, height, attributes, rotation_angle, rotation_center: RotationCenter { x: rotation_center_x, y: rotation_center_y, }, rendering: RenderingInfo { matrix_count, translation_matrix, matrix_sequence, }, }) } } /// Matrix 파싱 (표 85) / Parse matrix (Table 85) /// double array[6] (48바이트) - 3X2 matrix의 원소 / double array[6] (48 bytes) - Elements of 3X2 matrix fn parse_matrix(data: &[u8]) -> Result<Matrix, HwpError> { if data.len() < 48 { return Err(HwpError::insufficient_data("Matrix", 48, data.len())); } let mut elements = [0.0; 6]; for (i, element) in elements.iter_mut().enumerate() { let offset = i * 8; *element = f64::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], data[offset + 4], data[offset + 5], data[offset + 6], data[offset + 7], ]); } Ok(Matrix { elements }) }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/shape_component/line.rs	crates/hwp-core/src/document/bodytext/shape_component/line.rs	/// ShapeComponentLine 구조체 / ShapeComponentLine structure /// /// 스펙 문서 매핑: 표 92 - 선 개체 속성 / Spec mapping: Table 92 - Line shape component attributes /// /// 구현 상태 / Implementation Status /// - 구현 완료 / Implementation complete /// - 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_LINE 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain SHAPE_COMPONENT_LINE records use crate::error::HwpError; use crate::types::{INT32, UINT16}; use serde::{Deserialize, Serialize}; /// 선 개체 / Line shape component #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ShapeComponentLine { /// 시작점 / Start point pub start_point: Point, /// 끝점 / End point pub end_point: Point, /// 속성 / Attributes /// 처음 생성 시 수직 또는 수평선일 때, 선의 방향이 언제나 오른쪽(위쪽)으로 잡힘으로 인한 현상 때문에, 방향을 바로 잡아주기 위한 플래그 /// Flag to correct direction when initially created as vertical or horizontal line, /// as the direction is always set to right (up) due to a phenomenon pub flag: UINT16, } /// 점 좌표 / Point coordinates #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct Point { /// X 좌표 / X coordinate pub x: INT32, /// Y 좌표 / Y coordinate pub y: INT32, } impl ShapeComponentLine { /// ShapeComponentLine을 바이트 배열에서 파싱합니다. / Parse ShapeComponentLine from byte array. /// /// # Arguments /// * `data` - ShapeComponentLine 데이터 (선 개체 속성 부분만) / ShapeComponentLine data (line shape component attributes only) /// /// # Returns /// 파싱된 ShapeComponentLine 구조체 / Parsed ShapeComponentLine structure /// /// # Note /// 스펙 문서 표 91에 따르면 SHAPE_COMPONENT_LINE은 다음 구조를 가집니다: /// - 개체 공통 속성(표 68 참조) - 가변 길이 /// - 그리기 개체 공통 속성(표 81 참조) - 가변 길이 /// - 선 개체 속성(표 92 참조) - 18바이트 /// /// 레거시 코드(hwp.js)는 선 개체 속성 부분만 파싱하고 있습니다. /// According to spec Table 91, SHAPE_COMPONENT_LINE has the following structure: /// - Object common properties (Table 68) - variable length /// - Drawing object common properties (Table 81) - variable length /// - Line shape component attributes (Table 92) - 18 bytes /// /// Legacy code (hwp.js) only parses the line shape component attributes part. /// /// 테스트 상태 / Testing Status /// 현재 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_LINE 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 SHAPE_COMPONENT_LINE 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain SHAPE_COMPONENT_LINE records, so it has not been verified with actual files. /// If an actual HWP file contains SHAPE_COMPONENT_LINE records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // 표 92: 선 개체 속성은 18바이트 / Table 92: Line shape component attributes is 18 bytes // INT32(4) + INT32(4) + INT32(4) + INT32(4) + UINT16(2) = 18 bytes if data.len() < 18 { return Err(HwpError::insufficient_data("ShapeComponentLine", 18, data.len())); } let mut offset = 0; // 표 92: 시작점 X 좌표 (INT32, 4바이트) / Table 92: Start point X coordinate (INT32, 4 bytes) let start_x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 92: 시작점 Y 좌표 (INT32, 4바이트) / Table 92: Start point Y coordinate (INT32, 4 bytes) let start_y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 92: 끝점 X 좌표 (INT32, 4바이트) / Table 92: End point X coordinate (INT32, 4 bytes) let end_x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 92: 끝점 Y 좌표 (INT32, 4바이트) / Table 92: End point Y coordinate (INT32, 4 bytes) let end_y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 92: 속성 (UINT16, 2바이트) / Table 92: Attributes (UINT16, 2 bytes) let flag = UINT16::from_le_bytes([data[offset], data[offset + 1]]); Ok(ShapeComponentLine { start_point: Point { x: start_x, y: start_y, }, end_point: Point { x: end_x, y: end_y }, flag, }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/shape_component/ellipse.rs	crates/hwp-core/src/document/bodytext/shape_component/ellipse.rs	/// ShapeComponentEllipse 구조체 / ShapeComponentEllipse structure /// /// 스펙 문서 매핑: 표 96 - 타원 개체 속성 / Spec mapping: Table 96 - Ellipse shape component attributes /// /// 구현 상태 / Implementation Status /// - 구현 완료 / Implementation complete /// - 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_ELLIPSE 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain SHAPE_COMPONENT_ELLIPSE records use crate::error::HwpError; use crate::types::{INT32, UINT32}; use serde::{Deserialize, Serialize}; /// 타원 개체 / Ellipse shape component #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ShapeComponentEllipse { /// 속성 / Attributes (표 97 참조 / See Table 97) pub attributes: EllipseArcAttributes, /// 중심 좌표 / Center coordinates pub center: Point, /// 제1축 좌표 / First axis coordinates pub axis1: Point, /// 제2축 좌표 / Second axis coordinates pub axis2: Point, /// 시작 위치 / Start position pub start_pos: Point, /// 끝 위치 / End position pub end_pos: Point, /// 시작 위치 2 / Start position 2 pub start_pos2: Point, /// 곡선 간격 (호일 때만 유효) / Interval of curve (effective only when it is an arc) pub interval: INT32, /// 끝 위치 2 / End position 2 pub end_pos2: Point, } /// 타원/호 개체 속성 / Ellipse/Arc shape component attributes #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct EllipseArcAttributes { /// 호(ARC)로 바뀌었을 때, interval을 다시 계산해야 할 필요가 있는지 여부 / Whether interval needs to be recalculated when changed to ARC /// (interval - 원 위에 존재하는 두 점 사이의 거리) / (interval - distance between two points on the circle) pub needs_interval_recalculation: bool, /// 호(ARC)로 바뀌었는지 여부 / Whether it has been changed to ARC pub is_arc: bool, /// 호(ARC)의 종류 / ARC type pub arc_type: u8, } /// 점 좌표 / Point coordinates #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct Point { /// X 좌표 / X coordinate pub x: INT32, /// Y 좌표 / Y coordinate pub y: INT32, } impl ShapeComponentEllipse { /// ShapeComponentEllipse을 바이트 배열에서 파싱합니다. / Parse ShapeComponentEllipse from byte array. /// /// # Arguments /// * `data` - ShapeComponentEllipse 데이터 (타원 개체 속성 부분만) / ShapeComponentEllipse data (ellipse shape component attributes only) /// /// # Returns /// 파싱된 ShapeComponentEllipse 구조체 / Parsed ShapeComponentEllipse structure /// /// # Note /// 스펙 문서 표 95에 따르면 SHAPE_COMPONENT_ELLIPSE은 다음 구조를 가집니다: /// - 개체 공통 속성(표 68 참조) - 가변 길이 /// - 그리기 개체 공통 속성(표 81 참조) - 가변 길이 /// - 타원 개체 속성(표 96 참조) - 60바이트 /// /// 레거시 코드(hwp.js)는 타원 개체 속성 부분만 파싱하고 있습니다. /// According to spec Table 95, SHAPE_COMPONENT_ELLIPSE has the following structure: /// - Object common properties (Table 68) - variable length /// - Drawing object common properties (Table 81) - variable length /// - Ellipse shape component attributes (Table 96) - 60 bytes /// /// Legacy code (hwp.js) only parses the ellipse shape component attributes part. /// /// 테스트 상태 / Testing Status /// 현재 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_ELLIPSE 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 SHAPE_COMPONENT_ELLIPSE 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain SHAPE_COMPONENT_ELLIPSE records, so it has not been verified with actual files. /// If an actual HWP file contains SHAPE_COMPONENT_ELLIPSE records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // 표 96: 타원 개체 속성은 60바이트 / Table 96: Ellipse shape component attributes is 60 bytes // UINT32(4) + INT32(4) * 14 = 60 bytes if data.len() < 60 { return Err(HwpError::insufficient_data("ShapeComponentEllipse", 60, data.len())); } let mut offset = 0; // 표 96: 속성 (UINT32, 4바이트) / Table 96: Attributes (UINT32, 4 bytes) let attr_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 97: 속성 비트 필드 파싱 / Table 97: Parse attribute bit fields let needs_interval_recalculation = (attr_value & 0x01) != 0; // bit 0 let is_arc = (attr_value & 0x02) != 0; // bit 1 let arc_type = ((attr_value >> 2) & 0xFF) as u8; // bit 2-9 // 표 96: 중심 좌표의 X 값 (INT32, 4바이트) / Table 96: Center X coordinate (INT32, 4 bytes) let center_x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 96: 중심 좌표의 Y 값 (INT32, 4바이트) / Table 96: Center Y coordinate (INT32, 4 bytes) let center_y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 96: 제1축 X 좌표 값 (INT32, 4바이트) / Table 96: First axis X coordinate (INT32, 4 bytes) let axis1_x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 96: 제1축 Y 좌표 값 (INT32, 4바이트) / Table 96: First axis Y coordinate (INT32, 4 bytes) let axis1_y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 96: 제2축 X 좌표 값 (INT32, 4바이트) / Table 96: Second axis X coordinate (INT32, 4 bytes) let axis2_x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 96: 제2축 Y 좌표 값 (INT32, 4바이트) / Table 96: Second axis Y coordinate (INT32, 4 bytes) let axis2_y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 96: start pos x (INT32, 4바이트) / Table 96: Start position X (INT32, 4 bytes) let start_pos_x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 96: start pos y (INT32, 4바이트) / Table 96: Start position Y (INT32, 4 bytes) let start_pos_y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 96: end pos x (INT32, 4바이트) / Table 96: End position X (INT32, 4 bytes) let end_pos_x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 96: end pos y (INT32, 4바이트) / Table 96: End position Y (INT32, 4 bytes) let end_pos_y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 96: start pos x2 (INT32, 4바이트) / Table 96: Start position X2 (INT32, 4 bytes) let start_pos2_x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 96: interval of curve (INT32, 4바이트) / Table 96: Interval of curve (INT32, 4 bytes) let interval = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 96: start pos y2 (INT32, 4바이트) / Table 96: Start position Y2 (INT32, 4 bytes) let start_pos2_y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 96: end pos x2 (INT32, 4바이트) / Table 96: End position X2 (INT32, 4 bytes) let end_pos_x2 = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 96: end pos y2 (INT32, 4바이트) / Table 96: End position Y2 (INT32, 4 bytes) let end_pos_y2 = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); Ok(ShapeComponentEllipse { attributes: EllipseArcAttributes { needs_interval_recalculation, is_arc, arc_type, }, center: Point { x: center_x, y: center_y, }, axis1: Point { x: axis1_x, y: axis1_y, }, axis2: Point { x: axis2_x, y: axis2_y, }, start_pos: Point { x: start_pos_x, y: start_pos_y, }, end_pos: Point { x: end_pos_x, y: end_pos_y, }, start_pos2: Point { x: start_pos2_x, y: start_pos2_y, }, interval, end_pos2: Point { x: end_pos_x2, y: end_pos_y2, }, }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/shape_component/arc.rs	crates/hwp-core/src/document/bodytext/shape_component/arc.rs	/// ShapeComponentArc 구조체 / ShapeComponentArc structure /// /// 스펙 문서 매핑: 표 101 - 호 개체 속성 / Spec mapping: Table 101 - Arc shape component attributes /// /// 구현 상태 / Implementation Status /// - 구현 완료 / Implementation complete /// - 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_ARC 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain SHAPE_COMPONENT_ARC records use crate::error::HwpError; use crate::types::{INT32, UINT32}; use serde::{Deserialize, Serialize}; /// 호 개체 / Arc shape component #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ShapeComponentArc { /// 속성 / Attributes (표 97 참조 / See Table 97) pub attributes: EllipseArcAttributes, /// 타원의 중심 좌표 / Ellipse center coordinates pub ellipse_center: Point, /// 제1축 좌표 / First axis coordinates pub axis1: Point, /// 제2축 좌표 / Second axis coordinates pub axis2: Point, } /// 타원/호 개체 속성 / Ellipse/Arc shape component attributes #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct EllipseArcAttributes { /// 호(ARC)로 바뀌었을 때, interval을 다시 계산해야 할 필요가 있는지 여부 / Whether interval needs to be recalculated when changed to ARC /// (interval - 원 위에 존재하는 두 점 사이의 거리) / (interval - distance between two points on the circle) pub needs_interval_recalculation: bool, /// 호(ARC)로 바뀌었는지 여부 / Whether it has been changed to ARC pub is_arc: bool, /// 호(ARC)의 종류 / ARC type pub arc_type: u8, } /// 점 좌표 / Point coordinates #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct Point { /// X 좌표 / X coordinate pub x: INT32, /// Y 좌표 / Y coordinate pub y: INT32, } impl ShapeComponentArc { /// ShapeComponentArc을 바이트 배열에서 파싱합니다. / Parse ShapeComponentArc from byte array. /// /// # Arguments /// * `data` - ShapeComponentArc 데이터 (호 개체 속성 부분만) / ShapeComponentArc data (arc shape component attributes only) /// /// # Returns /// 파싱된 ShapeComponentArc 구조체 / Parsed ShapeComponentArc structure /// /// # Note /// 스펙 문서 표 100에 따르면 SHAPE_COMPONENT_ARC은 다음 구조를 가집니다: /// - 개체 공통 속성(표 68 참조) - 가변 길이 /// - 그리기 개체 공통 속성(표 81 참조) - 가변 길이 /// - 호 개체 속성(표 101 참조) - 28바이트 /// /// 레거시 코드(hwp.js)는 호 개체 속성 부분만 파싱하고 있습니다. /// According to spec Table 100, SHAPE_COMPONENT_ARC has the following structure: /// - Object common properties (Table 68) - variable length /// - Drawing object common properties (Table 81) - variable length /// - Arc shape component attributes (Table 101) - 28 bytes /// /// Legacy code (hwp.js) only parses the arc shape component attributes part. /// /// 테스트 상태 / Testing Status /// 현재 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_ARC 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 SHAPE_COMPONENT_ARC 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain SHAPE_COMPONENT_ARC records, so it has not been verified with actual files. /// If an actual HWP file contains SHAPE_COMPONENT_ARC records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // 표 101: 호 개체 속성은 28바이트 / Table 101: Arc shape component attributes is 28 bytes // UINT32(4) + INT32(4) * 6 = 28 bytes if data.len() < 28 { return Err(HwpError::insufficient_data("ShapeComponentArc", 28, data.len())); } let mut offset = 0; // 표 101: 속성 (UINT32, 4바이트) / Table 101: Attributes (UINT32, 4 bytes) let attr_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 97: 속성 비트 필드 파싱 / Table 97: Parse attribute bit fields let needs_interval_recalculation = (attr_value & 0x01) != 0; // bit 0 let is_arc = (attr_value & 0x02) != 0; // bit 1 let arc_type = ((attr_value >> 2) & 0xFF) as u8; // bit 2-9 // 표 101: 타원의 중심 좌표 X 값 (INT32, 4바이트) / Table 101: Ellipse center X coordinate (INT32, 4 bytes) let center_x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 101: 타원의 중심 좌표 Y 값 (INT32, 4바이트) / Table 101: Ellipse center Y coordinate (INT32, 4 bytes) let center_y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 101: 제1축 X 좌표 값 (INT32, 4바이트) / Table 101: First axis X coordinate (INT32, 4 bytes) let axis1_x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 101: 제1축 Y 좌표 값 (INT32, 4바이트) / Table 101: First axis Y coordinate (INT32, 4 bytes) let axis1_y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 101: 제2축 X 좌표 값 (INT32, 4바이트) / Table 101: Second axis X coordinate (INT32, 4 bytes) let axis2_x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 101: 제2축 Y 좌표 값 (INT32, 4바이트) / Table 101: Second axis Y coordinate (INT32, 4 bytes) let axis2_y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); Ok(ShapeComponentArc { attributes: EllipseArcAttributes { needs_interval_recalculation, is_arc, arc_type, }, ellipse_center: Point { x: center_x, y: center_y, }, axis1: Point { x: axis1_x, y: axis1_y, }, axis2: Point { x: axis2_x, y: axis2_y, }, }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/field.rs	crates/hwp-core/src/document/bodytext/ctrl_header/field.rs	use crate::error::HwpError; use crate::types::decode_utf16le; use crate::types::{UINT16, UINT32, UINT8}; use super::types::CtrlHeaderData; /// 필드 파싱 (표 152) / Parse field (Table 152) pub(crate) fn parse_field(data: &[u8]) -> Result<CtrlHeaderData, HwpError> { if data.len() < 15 { return Err(HwpError::insufficient_data("Field data", 15, data.len())); } let mut offset = 0usize; let field_type_bytes = [ data[offset + 3], data[offset + 2], data[offset + 1], data[offset], ]; let field_type = String::from_utf8_lossy(&field_type_bytes) .trim_end_matches('\0') .to_string(); offset += 4; let attribute = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let other_attr = UINT8::from_le_bytes([data[offset]]); offset += 1; let command_len = UINT16::from_le_bytes([data[offset], data[offset + 1]]) as usize; offset += 2; let command = if command_len > 0 && offset + (command_len * 2) <= data.len() { let command_bytes = &data[offset..offset + (command_len * 2)]; decode_utf16le(command_bytes).unwrap_or_default() } else { String::new() }; offset += command_len * 2; let id = if offset + 4 <= data.len() { UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]) } else { 0 }; Ok(CtrlHeaderData::Field { field_type, attribute, other_attr, command_len: command_len as UINT16, command, id, }) }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/object_common.rs	crates/hwp-core/src/document/bodytext/ctrl_header/object_common.rs	use crate::error::HwpError; use crate::types::decode_utf16le; use crate::types::{HWPUNIT, HWPUNIT16, INT32, SHWPUNIT, UINT16, UINT32}; use super::types::{ CtrlHeaderData, HorzRelTo, Margin, ObjectAttribute, ObjectCategory, ObjectHeightStandard, ObjectTextOption, ObjectTextPositionOption, ObjectWidthStandard, VertRelTo, }; /// 개체 공통 속성 파싱 (표 69) / Parse object common properties (Table 69) pub(crate) fn parse_object_common(data: &[u8]) -> Result<CtrlHeaderData, HwpError> { if data.len() < 40 { return Err(HwpError::insufficient_data( "Object common properties", 40, data.len(), )); } let mut offset = 0usize; let attribute_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let offset_y = SHWPUNIT::from(INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; let offset_x = SHWPUNIT::from(INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; let width = HWPUNIT::from(UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; let height = HWPUNIT::from(UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; let z_order = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let margin_bottom = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let margin_left = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let margin_right = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let margin_top = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let instance_id = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let page_divide = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let description = if offset + 2 <= data.len() { let description_len = UINT16::from_le_bytes([data[offset], data[offset + 1]]) as usize; offset += 2; if description_len > 0 && offset + (description_len * 2) <= data.len() { let description_bytes = &data[offset..offset + (description_len * 2)]; match decode_utf16le(description_bytes) { Ok(text) if !text.is_empty() => Some(text), _ => None, } } else { None } } else { None }; let attribute = parse_object_attribute(attribute_value); Ok(CtrlHeaderData::ObjectCommon { attribute, offset_y, offset_x, width, height, z_order, margin: Margin { top: margin_top, right: margin_right, bottom: margin_bottom, left: margin_left, }, instance_id, page_divide, description, caption: None, }) } /// 개체 속성 파싱 (표 70) / Parse object attribute (Table 70) fn parse_object_attribute(value: UINT32) -> ObjectAttribute { let like_letters = (value & 0x01) != 0; let affect_line_spacing = (value & 0x04) != 0; let vert_rel_to = match (value >> 3) & 0x03 { 0 => VertRelTo::Paper, 1 => VertRelTo::Page, 2 => VertRelTo::Para, _ => VertRelTo::Para, }; let vert_relative = ((value >> 5) & 0x07) as u8; // NOTE (HWP spec Table 70): // vert_rel_to has Paper/Page/Para; horz_rel_to also has Paper/Page/Column/Para. // Previously we collapsed (0\|1) into Page which loses "paper" anchors and breaks fixtures // (e.g. table-position '표 5' should be paper-left 35mm, but became page-left 65mm). let horz_rel_to = match (value >> 8) & 0x03 { 0 => HorzRelTo::Paper, 1 => HorzRelTo::Page, 2 => HorzRelTo::Column, 3 => HorzRelTo::Para, _ => HorzRelTo::Page, }; let horz_relative = ((value >> 10) & 0x07) as u8; let vert_rel_to_para_limit = (value & 0x2000) != 0; let overlap = (value & 0x4000) != 0; let object_width_standard = match (value >> 15) & 0x07 { 0 => ObjectWidthStandard::Paper, 1 => ObjectWidthStandard::Page, 2 => ObjectWidthStandard::Column, 3 => ObjectWidthStandard::Para, 4 => ObjectWidthStandard::Absolute, _ => ObjectWidthStandard::Absolute, }; let object_height_standard = match (value >> 18) & 0x03 { 0 => ObjectHeightStandard::Paper, 1 => ObjectHeightStandard::Page, 2 => ObjectHeightStandard::Absolute, _ => ObjectHeightStandard::Absolute, }; let object_text_option = match (value >> 21) & 0x07 { 0 => ObjectTextOption::Square, 1 => ObjectTextOption::Tight, 2 => ObjectTextOption::Through, 3 => ObjectTextOption::TopAndBottom, 4 => ObjectTextOption::BehindText, 5 => ObjectTextOption::InFrontOfText, _ => ObjectTextOption::Square, }; let object_text_position_option = match (value >> 24) & 0x03 { 0 => ObjectTextPositionOption::BothSides, 1 => ObjectTextPositionOption::LeftOnly, 2 => ObjectTextPositionOption::RightOnly, 3 => ObjectTextPositionOption::LargestOnly, _ => ObjectTextPositionOption::BothSides, }; let object_category = match (value >> 26) & 0x07 { 0 => ObjectCategory::None, 1 => ObjectCategory::Figure, 2 => ObjectCategory::Table, 3 => ObjectCategory::Equation, _ => ObjectCategory::None, }; let size_protect = (value & 0x100000) != 0; ObjectAttribute { like_letters, affect_line_spacing, vert_rel_to, vert_relative, horz_rel_to, horz_relative, vert_rel_to_para_limit, overlap, object_width_standard, object_height_standard, object_text_option, object_text_position_option, object_category, size_protect, } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/bookmark_marker.rs	crates/hwp-core/src/document/bodytext/ctrl_header/bookmark_marker.rs	use crate::error::HwpError; use crate::types::decode_utf16le; use crate::types::UINT16; use super::types::CtrlHeaderData; /// 찾아보기 표식 파싱 (표 149) / Parse bookmark marker (Table 149) pub(crate) fn parse_bookmark_marker(data: &[u8]) -> Result<CtrlHeaderData, HwpError> { if data.len() < 6 { return Err(HwpError::insufficient_data("Bookmark marker", 6, data.len())); } let mut offset = 0usize; let keyword1_len = UINT16::from_le_bytes([data[offset], data[offset + 1]]) as usize; offset += 2; let keyword1 = if keyword1_len > 0 && offset + (keyword1_len * 2) <= data.len() { let keyword1_bytes = &data[offset..offset + (keyword1_len * 2)]; decode_utf16le(keyword1_bytes).unwrap_or_default() } else { String::new() }; offset += keyword1_len * 2; let keyword2_len = if offset + 2 <= data.len() { UINT16::from_le_bytes([data[offset], data[offset + 1]]) as usize } else { 0 }; offset += 2; let keyword2 = if keyword2_len > 0 && offset + (keyword2_len * 2) <= data.len() { let keyword2_bytes = &data[offset..offset + (keyword2_len * 2)]; decode_utf16le(keyword2_bytes).unwrap_or_default() } else { String::new() }; Ok(CtrlHeaderData::BookmarkMarker { keyword1, keyword2 }) }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/page_number_position.rs	crates/hwp-core/src/document/bodytext/ctrl_header/page_number_position.rs	use crate::error::HwpError; use crate::types::decode_utf16le; use crate::types::UINT32; use super::types::{CtrlHeaderData, PageNumberPosition, PageNumberPositionFlags}; /// 쪽 번호 위치 파싱 (표 147) / Parse page number position (Table 147) pub(crate) fn parse_page_number_position(data: &[u8]) -> Result<CtrlHeaderData, HwpError> { if data.len() < 12 { return Err(HwpError::insufficient_data( "PageNumberPosition", 12, data.len(), )); } let mut offset = 0usize; let flags_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let shape = (flags_value & 0xFF) as u8; let position = match (flags_value >> 8) & 0x0F { 0 => PageNumberPosition::None, 1 => PageNumberPosition::TopLeft, 2 => PageNumberPosition::TopCenter, 3 => PageNumberPosition::TopRight, 4 => PageNumberPosition::BottomLeft, 5 => PageNumberPosition::BottomCenter, 6 => PageNumberPosition::BottomRight, 7 => PageNumberPosition::OutsideTop, 8 => PageNumberPosition::OutsideBottom, 9 => PageNumberPosition::InsideTop, 10 => PageNumberPosition::InsideBottom, _ => PageNumberPosition::None, }; let flags = PageNumberPositionFlags { shape, position }; let user_symbol = decode_utf16le(&data[offset..offset + 2])?; offset += 2; let prefix = decode_utf16le(&data[offset..offset + 2])?; offset += 2; let suffix = decode_utf16le(&data[offset..offset + 2])?; Ok(CtrlHeaderData::PageNumberPosition { flags, user_symbol, prefix, suffix, }) }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/footnote_endnote.rs	crates/hwp-core/src/document/bodytext/ctrl_header/footnote_endnote.rs	use crate::error::HwpError; use super::types::CtrlHeaderData; /// 각주/미주 파싱 (표 4.3.10.4) / Parse footnote/endnote (Table 4.3.10.4) pub(crate) fn parse_footnote_endnote(data: &[u8]) -> Result<CtrlHeaderData, HwpError> { if data.len() < 8 { return Err(HwpError::insufficient_data( "Footnote/endnote", 8, data.len(), )); } let number = data[0]; let mut reserved = [0u8; 5]; reserved.copy_from_slice(&data[1..6]); let attribute = data[6]; let reserved2 = data[7]; Ok(CtrlHeaderData::FootnoteEndnote { number, reserved, attribute, reserved2, }) }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/hide.rs	crates/hwp-core/src/document/bodytext/ctrl_header/hide.rs	use crate::error::HwpError; use crate::types::UINT16; use super::types::CtrlHeaderData; /// 감추기 파싱 (표 145) / Parse hide (Table 145) pub(crate) fn parse_hide(data: &[u8]) -> Result<CtrlHeaderData, HwpError> { if data.len() < 2 { return Err(HwpError::insufficient_data("Hide", 2, data.len())); } let attribute = UINT16::from_le_bytes([data[0], data[1]]); Ok(CtrlHeaderData::Hide { attribute }) }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/header_footer.rs	crates/hwp-core/src/document/bodytext/ctrl_header/header_footer.rs	use crate::error::HwpError; use crate::types::{HWPUNIT, UINT32}; use super::types::{ApplyPage, CtrlHeaderData, HeaderFooterAttribute}; /// 머리말/꼬리말 파싱 (표 140) / Parse header/footer (Table 140) pub(crate) fn parse_header_footer(data: &[u8]) -> Result<CtrlHeaderData, HwpError> { if data.len() < 4 { return Err(HwpError::insufficient_data("Header/Footer", 4, data.len())); } let mut offset = 0usize; let attribute_value = UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]); offset += 4; let apply_page = match attribute_value & 0x03 { 0 => ApplyPage::Both, 1 => ApplyPage::EvenOnly, 2 => ApplyPage::OddOnly, _ => ApplyPage::Both, }; let attribute = HeaderFooterAttribute { apply_page }; let text_width = if offset + 4 <= data.len() { HWPUNIT::from(UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])) } else { HWPUNIT::from(0) }; offset += 4; let text_height = if offset + 4 <= data.len() { HWPUNIT::from(UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])) } else { HWPUNIT::from(0) }; offset += 4; let text_ref = if offset < data.len() { data[offset] } else { 0 }; offset += 1; let number_ref = if offset < data.len() { data[offset] } else { 0 }; Ok(CtrlHeaderData::HeaderFooter { attribute, text_width, text_height, text_ref, number_ref, }) }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/ids.rs	crates/hwp-core/src/document/bodytext/ctrl_header/ids.rs	/// 컨트롤 ID 상수 정의 / Control ID constants definition /// /// 스펙 문서 매핑: 표 127 - 개체 이외의 컨트롤과 컨트롤 ID, 표 128 - 필드 컨트롤 ID /// Spec mapping: Table 127 - Controls other than objects and Control IDs, Table 128 - Field Control IDs pub struct CtrlId; impl CtrlId { // 개체 컨트롤 ID / Object Control IDs /// 테이블 컨트롤 / Table control /// 개체 공통 속성을 가지는 컨트롤 ID / Control ID with object common properties pub const TABLE: &str = "tbl "; /// 일반 그리기 개체 / General shape object /// 개체 공통 속성을 가지는 컨트롤 ID / Control ID with object common properties pub const SHAPE_OBJECT: &str = "gso "; // 표 127: 개체 이외의 컨트롤과 컨트롤 ID / Table 127: Controls other than objects and Control IDs /// 구역 정의 / Section definition /// 스펙 문서: 표 127, 표 129 참조 / Spec: See Table 127, Table 129 pub const SECTION_DEF: &str = "secd"; /// 단 정의 / Column definition pub const COLUMN_DEF: &str = "cold"; /// 머리말 / Header pub const HEADER: &str = "head"; /// 꼬리말 / Footer pub const FOOTER: &str = "foot"; /// 각주 / Footnote (공백 포함) pub const FOOTNOTE: &str = "fn "; /// 미주 / Endnote (공백 포함) pub const ENDNOTE: &str = "en "; /// 머리말/꼬리말 (레거시 호환용) / Header/Footer (legacy compatibility) #[deprecated(note = "Use HEADER or FOOTER instead")] pub const HEADER_FOOTER: &str = "head"; /// 자동번호 / Auto numbering /// /// NOTE: /// - 실제 파일/레거시 구현에서 `"atno"`로 나타나는 경우가 있습니다. /// - 따라서 파서는 `"autn"`과 `"atno"` 모두를 자동번호 컨트롤로 처리합니다. pub const AUTO_NUMBER: &str = "autn"; /// 자동번호(대체 CHID) / Auto numbering (alternate CHID) pub const AUTO_NUMBER_ALT: &str = "atno"; /// 새 번호 지정 / New number specification pub const NEW_NUMBER: &str = "newn"; /// 감추기 / Hide pub const HIDE: &str = "pghd"; /// 홀/짝수 조정 / Odd/Even page adjustment pub const PAGE_ADJUST: &str = "pgad"; /// 쪽 번호 위치 / Page number position pub const PAGE_NUMBER: &str = "pgno"; /// 쪽 번호 위치 (pgnp) / Page number position (pgnp) pub const PAGE_NUMBER_POS: &str = "pgnp"; /// 찾아보기 표식 / Bookmark marker pub const BOOKMARK_MARKER: &str = "bkmk"; /// 글자 겹침 / Character overlap pub const OVERLAP: &str = "over"; /// 덧말 / Comment pub const COMMENT: &str = "cmtt"; /// 숨은 설명 / Hidden description pub const HIDDEN_DESC: &str = "hide"; /// 필드 시작 / Field start pub const FIELD_START: &str = "%%%%"; // 표 128: 필드 컨트롤 ID / Table 128: Field Control IDs pub const FIELD_UNKNOWN: &str = "%unk"; pub const FIELD_DATE: &str = "%dte"; pub const FIELD_DOC_DATE: &str = "%ddt"; pub const FIELD_PATH: &str = "%pat"; pub const FIELD_BOOKMARK: &str = "%bmk"; pub const FIELD_CROSS_REF: &str = "%xrf"; pub const FIELD_FORMULA: &str = "%eqr"; pub const FIELD_DOCSUMMARY: &str = "%dsm"; pub const FIELD_USER: &str = "%usr"; pub const FIELD_MAIL_MERGE: &str = "%mmg"; pub const FIELD_HYPERLINK: &str = "%hlk"; pub const FIELD_REVISION: &str = "%rvs"; pub const FIELD_OUTLINE: &str = "%out"; pub const FIELD_TABLE_OF_CONTENTS: &str = "%toc"; pub const FIELD_INDEXMARK: &str = "%idx"; pub const FIELD_PAGECTRL: &str = "%pgc"; pub const FIELD_HWP_SUMMARY: &str = "%hsm"; pub const FIELD_KOGL: &str = "%kgl"; pub const FIELD_GLOSSARY: &str = "%gls"; pub const FIELD_INPUT: &str = "%inp"; pub const FIELD_CHANGE: &str = "%chg"; pub const FIELD_FILE: &str = "%fil"; pub const FIELD_PAGE_NUM: &str = "%pgn"; pub const FIELD_DOC_TITLE: &str = "%ttl"; pub const FIELD_DOC_AUTHOR: &str = "%aut"; pub const FIELD_DOC_KEYWORD: &str = "%key"; pub const FIELD_DOC_SUBJECT: &str = "%sub"; pub const FIELD_DOC_COMMENT: &str = "%cmt"; pub const FIELD_DOC_LASTSAVEDBY: &str = "%lsb"; pub const FIELD_DOC_REVISION: &str = "%rev"; pub const FIELD_DOC_LASTPRINTED: &str = "%lpt"; pub const FIELD_DOC_CREATED: &str = "%crt"; pub const FIELD_DOC_LASTSAVED: &str = "%sav"; pub const FIELD_DOC_PAGECOUNT: &str = "%pgc"; pub const FIELD_DOC_WORDCOUNT: &str = "%wct"; pub const FIELD_DOC_CHARCOUNT: &str = "%cct"; pub const FIELD_PRIVATE_INFO_SECURITY: &str = "%cpr"; pub const FIELD_TABLE_OF_CONTENTS_ALT: &str = "%oc"; }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/types.rs	crates/hwp-core/src/document/bodytext/ctrl_header/types.rs	use crate::types::{HWPUNIT, HWPUNIT16, INT32, INT8, SHWPUNIT, UINT16, UINT32, UINT8}; use serde::{Deserialize, Serialize}; /// 컨트롤 헤더 / Control header #[derive(Debug, Clone, Serialize, Deserialize)] pub struct CtrlHeader { /// 컨트롤 ID (4바이트, ASCII 문자열로 해석 가능) / Control ID (4 bytes, can be interpreted as ASCII string) pub ctrl_id: String, /// 컨트롤 ID 값 (UINT32) / Control ID value (UINT32) pub ctrl_id_value: UINT32, /// 컨트롤 ID 이후의 데이터 (CtrlID에 따라 다름) / Data after control ID (varies by CtrlID) #[serde(flatten)] pub data: CtrlHeaderData, } /// 캡션 정렬 (표 73) / Caption alignment (Table 73) #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum CaptionAlign { Left = 0, Right = 1, Top = 2, Bottom = 3, } /// 캡션 수직 정렬 (ListHeaderProperty bit 5-6) / Caption vertical alignment (ListHeaderProperty bit 5-6) #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum CaptionVAlign { Top = 0, Middle = 1, Bottom = 2, } /// 캡션 정보 (표 72) / Caption information (Table 72) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct Caption { pub align: CaptionAlign, pub include_margin: bool, pub width: HWPUNIT, pub gap: HWPUNIT16, pub last_width: HWPUNIT, #[serde(skip_serializing_if = "Option::is_none")] pub vertical_align: Option<CaptionVAlign>, } /// 컨트롤 헤더 데이터 (컨트롤 ID별 구조) / Control header data (structure varies by CtrlID) #[derive(Debug, Clone, Serialize, Deserialize)] #[serde(tag = "data_type", rename_all = "snake_case")] pub enum CtrlHeaderData { ObjectCommon { attribute: ObjectAttribute, offset_y: SHWPUNIT, offset_x: SHWPUNIT, width: HWPUNIT, height: HWPUNIT, z_order: INT32, margin: Margin, instance_id: UINT32, page_divide: INT32, description: Option<String>, caption: Option<Caption>, }, ColumnDefinition { attribute: ColumnDefinitionAttribute, column_spacing: HWPUNIT16, column_widths: Vec<HWPUNIT16>, attribute_high: UINT16, divider_line_type: UINT8, divider_line_thickness: UINT8, divider_line_color: UINT32, }, FootnoteEndnote { number: UINT8, reserved: [UINT8; 5], attribute: UINT8, reserved2: UINT8, }, HeaderFooter { attribute: HeaderFooterAttribute, text_width: HWPUNIT, text_height: HWPUNIT, text_ref: UINT8, number_ref: UINT8, }, PageNumberPosition { flags: PageNumberPositionFlags, user_symbol: String, prefix: String, suffix: String, }, Field { field_type: String, attribute: UINT32, other_attr: UINT8, command_len: UINT16, command: String, id: UINT32, }, SectionDefinition { attribute: UINT32, column_spacing: HWPUNIT16, vertical_alignment: HWPUNIT16, horizontal_alignment: HWPUNIT16, default_tip_spacing: HWPUNIT, number_para_shape_id: UINT16, page_number: UINT16, figure_number: UINT16, table_number: UINT16, equation_number: UINT16, language: UINT16, }, AutoNumber { attribute: UINT32, number: UINT16, user_symbol: String, prefix: String, suffix: String, }, NewNumber { attribute: UINT32, number: UINT16, }, Hide { attribute: UINT16, }, PageAdjust { attribute: UINT32, }, BookmarkMarker { keyword1: String, keyword2: String, }, Overlap { ctrl_id: String, text: String, border_type: UINT8, internal_text_size: INT8, border_internal_text_spread: UINT8, char_shape_ids: Vec<UINT32>, }, Comment { main_text: String, sub_text: String, position: UINT32, fsize_ratio: UINT32, option: UINT32, style_number: UINT32, alignment: UINT32, }, HiddenDescription, Other, } /// 개체 속성 / Object attribute #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ObjectAttribute { pub like_letters: bool, pub affect_line_spacing: bool, pub vert_rel_to: VertRelTo, pub vert_relative: UINT8, pub horz_rel_to: HorzRelTo, pub horz_relative: UINT8, pub vert_rel_to_para_limit: bool, pub overlap: bool, pub object_width_standard: ObjectWidthStandard, pub object_height_standard: ObjectHeightStandard, pub object_text_option: ObjectTextOption, pub object_text_position_option: ObjectTextPositionOption, pub object_category: ObjectCategory, pub size_protect: bool, } #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum VertRelTo { Paper, Page, Para, } #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum HorzRelTo { Paper, Page, Column, Para, } #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum ObjectWidthStandard { Paper, Page, Column, Para, Absolute, } #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum ObjectHeightStandard { Paper, Page, Absolute, } #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum ObjectTextOption { Square, Tight, Through, TopAndBottom, BehindText, InFrontOfText, } #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum ObjectTextPositionOption { BothSides, LeftOnly, RightOnly, LargestOnly, } #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum ObjectCategory { None, Figure, Table, Equation, } /// 단 정의 속성 (표 139) / Column definition attribute (Table 139) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ColumnDefinitionAttribute { pub column_type: ColumnType, pub column_count: UINT8, pub column_direction: ColumnDirection, pub equal_width: bool, } #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum ColumnType { Normal, Distributed, Parallel, } #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum ColumnDirection { Left, Right, Both, } /// 오브젝트의 바깥 4방향 여백 / Object outer margins (4 directions) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct Margin { pub top: HWPUNIT16, pub right: HWPUNIT16, pub bottom: HWPUNIT16, pub left: HWPUNIT16, } /// 쪽 번호 위치 속성 (표 148) / Page number position attributes (Table 148) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct PageNumberPositionFlags { pub shape: u8, pub position: PageNumberPosition, } /// 쪽 번호의 표시 위치 / Page number display position #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum PageNumberPosition { None, TopLeft, TopCenter, TopRight, BottomLeft, BottomCenter, BottomRight, OutsideTop, OutsideBottom, InsideTop, InsideBottom, } /// 머리말/꼬리말 속성 (표 141) / Header/Footer attribute (Table 141) #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct HeaderFooterAttribute { pub apply_page: ApplyPage, } #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum ApplyPage { Both, EvenOnly, OddOnly, }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/overlap.rs	crates/hwp-core/src/document/bodytext/ctrl_header/overlap.rs	use crate::error::HwpError; use crate::types::decode_utf16le; use crate::types::{INT8, UINT16, UINT32, UINT8}; use super::types::CtrlHeaderData; /// 글자 겹침 파싱 (표 150) / Parse character overlap (Table 150) pub(crate) fn parse_overlap(data: &[u8]) -> Result<CtrlHeaderData, HwpError> { if data.len() < 10 { return Err(HwpError::insufficient_data("Overlap", 10, data.len())); } let mut offset = 0usize; let ctrl_id_bytes = [data[offset + 3], data[offset + 2], data[offset + 1], data[offset]]; let ctrl_id = String::from_utf8_lossy(&ctrl_id_bytes) .trim_end_matches('\0') .to_string(); offset += 4; let text_len = UINT16::from_le_bytes([data[offset], data[offset + 1]]) as usize; offset += 2; let text = if text_len > 0 && offset + (text_len * 2) <= data.len() { let text_bytes = &data[offset..offset + (text_len * 2)]; decode_utf16le(text_bytes).unwrap_or_default() } else { String::new() }; offset += text_len * 2; let border_type = if offset < data.len() { UINT8::from_le_bytes([data[offset]]) } else { 0 }; offset += 1; let internal_text_size = if offset < data.len() { INT8::from_le_bytes([data[offset]]) } else { 0 }; offset += 1; let border_internal_text_spread = if offset < data.len() { UINT8::from_le_bytes([data[offset]]) } else { 0 }; offset += 1; let cnt = if offset < data.len() { UINT8::from_le_bytes([data[offset]]) as usize } else { 0 }; offset += 1; let mut char_shape_ids = Vec::new(); if cnt > 0 && offset + (cnt * 4) <= data.len() { for _ in 0..cnt { let id = UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]); char_shape_ids.push(id); offset += 4; } } Ok(CtrlHeaderData::Overlap { ctrl_id, text, border_type, internal_text_size, border_internal_text_spread, char_shape_ids, }) }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/mod.rs	crates/hwp-core/src/document/bodytext/ctrl_header/mod.rs	// CtrlHeader parsing/types split into modules. mod ids; mod types; mod auto_number; mod bookmark_marker; mod caption; mod column_definition; mod comment; mod field; mod footnote_endnote; mod header_footer; mod hide; mod object_common; mod overlap; mod page_adjust; mod page_number_position; mod section_definition; pub use ids::CtrlId; pub use types::*; pub use caption::parse_caption_from_list_header; use crate::error::HwpError; use crate::types::UINT32; impl CtrlHeader { /// CtrlHeader를 바이트 배열에서 파싱합니다. / Parse CtrlHeader from byte array. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 4 { return Err(HwpError::insufficient_data("CtrlHeader", 4, data.len())); } let ctrl_id_value = UINT32::from_le_bytes([data[0], data[1], data[2], data[3]]); // pyhwp처럼 바이트를 리버스해서 읽음 / Read bytes in reverse order like pyhwp let ctrl_id_bytes = [data[3], data[2], data[1], data[0]]; // 공백까지 포함해서 파싱 (trim_end 제거) / Parse including spaces (remove trim_end) let ctrl_id = String::from_utf8_lossy(&ctrl_id_bytes) .trim_end_matches('\0') .to_string(); let remaining_data = if data.len() > 4 { &data[4..] } else { &[] }; let parsed_data = match ctrl_id.as_str() { CtrlId::TABLE \| CtrlId::SHAPE_OBJECT => object_common::parse_object_common(remaining_data)?, CtrlId::COLUMN_DEF => column_definition::parse_column_definition(remaining_data)?, CtrlId::FOOTNOTE \| CtrlId::ENDNOTE => footnote_endnote::parse_footnote_endnote(remaining_data)?, CtrlId::HEADER \| CtrlId::FOOTER => header_footer::parse_header_footer(remaining_data)?, CtrlId::PAGE_NUMBER \| CtrlId::PAGE_NUMBER_POS => { page_number_position::parse_page_number_position(remaining_data)? } CtrlId::FIELD_START => field::parse_field(remaining_data)?, CtrlId::SECTION_DEF => section_definition::parse_section_definition(remaining_data)?, CtrlId::AUTO_NUMBER \| CtrlId::AUTO_NUMBER_ALT => auto_number::parse_auto_number(remaining_data)?, CtrlId::NEW_NUMBER => auto_number::parse_new_number(remaining_data)?, CtrlId::HIDE => hide::parse_hide(remaining_data)?, CtrlId::PAGE_ADJUST => page_adjust::parse_page_adjust(remaining_data)?, CtrlId::BOOKMARK_MARKER => bookmark_marker::parse_bookmark_marker(remaining_data)?, CtrlId::OVERLAP => overlap::parse_overlap(remaining_data)?, CtrlId::COMMENT => comment::parse_comment(remaining_data)?, CtrlId::HIDDEN_DESC => CtrlHeaderData::HiddenDescription, _ => CtrlHeaderData::Other, }; Ok(CtrlHeader { ctrl_id, ctrl_id_value, data: parsed_data, }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/column_definition.rs	crates/hwp-core/src/document/bodytext/ctrl_header/column_definition.rs	use crate::error::HwpError; use crate::types::{HWPUNIT16, UINT16, UINT32, UINT8}; use super::types::{ColumnDefinitionAttribute, ColumnDirection, ColumnType, CtrlHeaderData}; /// 단 정의 파싱 (표 138) / Parse column definition (Table 138) pub(crate) fn parse_column_definition(data: &[u8]) -> Result<CtrlHeaderData, HwpError> { if data.len() < 12 { return Err(HwpError::insufficient_data( "Column definition", 12, data.len(), )); } let mut offset = 0usize; let attribute_low = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let column_type = match attribute_low & 0x03 { 0 => ColumnType::Normal, 1 => ColumnType::Distributed, 2 => ColumnType::Parallel, _ => ColumnType::Normal, }; let column_count = ((attribute_low >> 2) & 0xFF) as UINT8; let column_count_u8 = if column_count == 0 { 1 } else { column_count }; let column_direction = match (attribute_low >> 10) & 0x03 { 0 => ColumnDirection::Left, 1 => ColumnDirection::Right, 2 => ColumnDirection::Both, _ => ColumnDirection::Left, }; let equal_width = (attribute_low & 0x1000) != 0; let attribute = ColumnDefinitionAttribute { column_type, column_count: column_count_u8, column_direction, equal_width, }; let column_spacing = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let mut column_widths = Vec::new(); if !equal_width { for _ in 0..column_count_u8 { if offset + 2 <= data.len() { column_widths.push(HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]])); offset += 2; } else { break; } } } let attribute_high = if offset + 2 <= data.len() { UINT16::from_le_bytes([data[offset], data[offset + 1]]) } else { 0 }; offset += 2; let divider_line_type = if offset < data.len() { data[offset] } else { 0 }; offset += 1; let divider_line_thickness = if offset < data.len() { data[offset] } else { 0 }; offset += 1; let divider_line_color = if offset + 4 <= data.len() { UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]) } else { 0 }; Ok(CtrlHeaderData::ColumnDefinition { attribute, column_spacing, column_widths, attribute_high, divider_line_type, divider_line_thickness, divider_line_color, }) }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/page_adjust.rs	crates/hwp-core/src/document/bodytext/ctrl_header/page_adjust.rs	use crate::error::HwpError; use crate::types::UINT32; use super::types::CtrlHeaderData; /// 홀/짝수 조정 파싱 (표 146) / Parse page adjustment (Table 146) pub(crate) fn parse_page_adjust(data: &[u8]) -> Result<CtrlHeaderData, HwpError> { if data.len() < 4 { return Err(HwpError::insufficient_data("Page adjust", 4, data.len())); } let attribute = UINT32::from_le_bytes([data[0], data[1], data[2], data[3]]); Ok(CtrlHeaderData::PageAdjust { attribute }) }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/auto_number.rs	crates/hwp-core/src/document/bodytext/ctrl_header/auto_number.rs	use crate::error::HwpError; use crate::types::decode_utf16le; use crate::types::{UINT16, UINT32}; use super::types::CtrlHeaderData; /// 자동번호 파싱 (표 142) / Parse auto number (Table 142) pub(crate) fn parse_auto_number(data: &[u8]) -> Result<CtrlHeaderData, HwpError> { if data.len() < 12 { return Err(HwpError::insufficient_data("Auto number", 12, data.len())); } let mut offset = 0usize; let attribute = UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]); offset += 4; let number = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let user_symbol = decode_utf16le(&data[offset..offset + 2]).unwrap_or_default(); offset += 2; let prefix = decode_utf16le(&data[offset..offset + 2]).unwrap_or_default(); offset += 2; let suffix = decode_utf16le(&data[offset..offset + 2]).unwrap_or_default(); Ok(CtrlHeaderData::AutoNumber { attribute, number, user_symbol, prefix, suffix, }) } /// 새 번호 지정 파싱 (표 144) / Parse new number specification (Table 144) pub(crate) fn parse_new_number(data: &[u8]) -> Result<CtrlHeaderData, HwpError> { if data.len() < 8 { return Err(HwpError::insufficient_data("New number", 8, data.len())); } let mut offset = 0usize; let attribute = UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]); offset += 4; let number = UINT16::from_le_bytes([data[offset], data[offset + 1]]); Ok(CtrlHeaderData::NewNumber { attribute, number }) }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/section_definition.rs	crates/hwp-core/src/document/bodytext/ctrl_header/section_definition.rs	use crate::error::HwpError; use crate::types::{HWPUNIT, HWPUNIT16, UINT16, UINT32}; use super::types::CtrlHeaderData; /// 구역 정의 파싱 (표 129) / Parse section definition (Table 129) pub(crate) fn parse_section_definition(data: &[u8]) -> Result<CtrlHeaderData, HwpError> { if data.len() < 24 { return Err(HwpError::insufficient_data( "Section definition", 24, data.len(), )); } let mut offset = 0usize; let attribute = UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]); offset += 4; let column_spacing = if offset + 2 <= data.len() { HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]) } else { 0 }; offset += 2; let vertical_alignment = if offset + 2 <= data.len() { HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]) } else { 0 }; offset += 2; let horizontal_alignment = if offset + 2 <= data.len() { HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]) } else { 0 }; offset += 2; let default_tip_spacing = if offset + 4 <= data.len() { HWPUNIT::from(UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])) } else { HWPUNIT::from(0) }; offset += 4; let number_para_shape_id = if offset + 2 <= data.len() { UINT16::from_le_bytes([data[offset], data[offset + 1]]) } else { 0 }; offset += 2; let page_number = if offset + 2 <= data.len() { UINT16::from_le_bytes([data[offset], data[offset + 1]]) } else { 0 }; offset += 2; let figure_number = if offset + 2 <= data.len() { UINT16::from_le_bytes([data[offset], data[offset + 1]]) } else { 0 }; offset += 2; let table_number = if offset + 2 <= data.len() { UINT16::from_le_bytes([data[offset], data[offset + 1]]) } else { 0 }; offset += 2; let equation_number = if offset + 2 <= data.len() { UINT16::from_le_bytes([data[offset], data[offset + 1]]) } else { 0 }; offset += 2; let language = if offset + 2 <= data.len() { UINT16::from_le_bytes([data[offset], data[offset + 1]]) } else { 0 }; Ok(CtrlHeaderData::SectionDefinition { attribute, column_spacing, vertical_alignment, horizontal_alignment, default_tip_spacing, number_para_shape_id, page_number, figure_number, table_number, equation_number, language, }) }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/caption.rs	crates/hwp-core/src/document/bodytext/ctrl_header/caption.rs	use crate::error::HwpError; use crate::types::{HWPUNIT, HWPUNIT16, UINT32}; // keep use super::types::{Caption, CaptionAlign, CaptionVAlign}; /// LIST_HEADER 레코드에서 캡션 파싱 (hwplib 방식) / Parse caption from LIST_HEADER record (hwplib approach) pub fn parse_caption_from_list_header(data: &[u8]) -> Result<Option<Caption>, HwpError> { if data.len() < 22 { return Ok(None); } let mut offset = 0usize; // paraCount (SInt4) - 4 bytes (read but not used) offset += 4; let list_header_property = UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]); offset += 4; let vertical_align = match (list_header_property >> 5) & 0x03 { 0 => CaptionVAlign::Top, 1 => CaptionVAlign::Middle, 2 => CaptionVAlign::Bottom, _ => CaptionVAlign::Middle, }; let caption_property_value = UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]); offset += 4; let align = match caption_property_value & 0x03 { 0 => CaptionAlign::Left, 1 => CaptionAlign::Right, 2 => CaptionAlign::Top, 3 => CaptionAlign::Bottom, _ => CaptionAlign::Bottom, }; let include_margin = (caption_property_value & 0x04) != 0; let width = HWPUNIT::from(UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]])); offset += 4; let gap = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let last_width = HWPUNIT::from(UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]])); Ok(Some(Caption { align, include_margin, width, gap, last_width, vertical_align: Some(vertical_align), })) } /// 캡션 파싱 (표 72 - 14바이트) / Parse caption (Table 72 - 14 bytes) #[allow(dead_code)] fn parse_caption(data: &[u8]) -> Result<Caption, HwpError> { if data.len() < 14 { return Err(HwpError::insufficient_data("Caption", 14, data.len())); } let mut offset = 0usize; let attribute_value = UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]); offset += 4; let align = match attribute_value & 0x03 { 0 => CaptionAlign::Left, 1 => CaptionAlign::Right, 2 => CaptionAlign::Top, 3 => CaptionAlign::Bottom, _ => CaptionAlign::Bottom, }; let include_margin = (attribute_value & 0x04) != 0; let width = HWPUNIT::from(UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]])); offset += 4; let gap = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let last_width = HWPUNIT::from(UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]])); Ok(Caption { align, include_margin, width, gap, last_width, vertical_align: None, }) } /// 캡션 파싱 (표 72 - 12바이트 버전) / Parse caption (Table 72 - 12 bytes version) #[allow(dead_code)] fn parse_caption_12bytes(data: &[u8]) -> Result<Caption, HwpError> { if data.len() < 12 { return Err(HwpError::insufficient_data( "Caption (12 bytes)", 12, data.len(), )); } let mut offset = 0usize; let attribute_value = UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]); offset += 4; let align = match attribute_value & 0x03 { 0 => CaptionAlign::Left, 1 => CaptionAlign::Right, 2 => CaptionAlign::Top, 3 => CaptionAlign::Bottom, _ => CaptionAlign::Bottom, }; let include_margin = (attribute_value & 0x04) != 0; let width = HWPUNIT::from(UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]])); offset += 4; let gap = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); let last_width = HWPUNIT::from(0); Ok(Caption { align, include_margin, width, gap, last_width, vertical_align: None, }) }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/comment.rs	crates/hwp-core/src/document/bodytext/ctrl_header/comment.rs	use crate::error::HwpError; use crate::types::decode_utf16le; use crate::types::{UINT16, UINT32}; use super::types::CtrlHeaderData; /// 덧말 파싱 (표 151) / Parse comment (Table 151) pub(crate) fn parse_comment(data: &[u8]) -> Result<CtrlHeaderData, HwpError> { if data.len() < 18 { return Err(HwpError::insufficient_data("Comment", 18, data.len())); } let mut offset = 0usize; let main_text_len = UINT16::from_le_bytes([data[offset], data[offset + 1]]) as usize; offset += 2; let main_text = if main_text_len > 0 && offset + (main_text_len * 2) <= data.len() { let main_text_bytes = &data[offset..offset + (main_text_len * 2)]; decode_utf16le(main_text_bytes).unwrap_or_default() } else { String::new() }; offset += main_text_len.max(1) * 2; let sub_text_len = if offset + 2 <= data.len() { UINT16::from_le_bytes([data[offset], data[offset + 1]]) as usize } else { 0 }; offset += 2; let sub_text = if sub_text_len > 0 && offset + (sub_text_len * 2) <= data.len() { let sub_text_bytes = &data[offset..offset + (sub_text_len * 2)]; decode_utf16le(sub_text_bytes).unwrap_or_default() } else { String::new() }; offset += sub_text_len.max(1) * 2; let position = if offset + 4 <= data.len() { UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]) } else { 0 }; offset += 4; let fsize_ratio = if offset + 4 <= data.len() { UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]) } else { 0 }; offset += 4; let option = if offset + 4 <= data.len() { UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]) } else { 0 }; offset += 4; let style_number = if offset + 4 <= data.len() { UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]) } else { 0 }; offset += 4; let alignment = if offset + 4 <= data.len() { UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]) } else { 0 }; Ok(CtrlHeaderData::Comment { main_text, sub_text, position, fsize_ratio, option, style_number, alignment, }) }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bindata/mod.rs	crates/hwp-core/src/document/bindata/mod.rs	/// BinData parsing module /// /// This module handles parsing of HWP BinData storage. /// /// 스펙 문서 매핑: 표 2 - 바이너리 데이터 (BinData 스토리지) use crate::decompress::decompress_deflate; use crate::document::docinfo::BinDataRecord; use crate::error::HwpError; use crate::types::WORD; use base64::{engine::general_purpose::STANDARD, Engine as _}; use cfb::CompoundFile; use serde::{Deserialize, Serialize}; use std::io::{Cursor, Read}; use std::path::Path; /// Binary data output format /// 바이너리 데이터 출력 형식 #[derive(Debug, Clone)] pub enum BinaryDataFormat { /// Base64 encoded string / Base64로 인코딩된 문자열 Base64, /// File path where binary data is saved / 바이너리 데이터가 저장된 파일 경로 File(String), } /// Binary data structure #[derive(Debug, Clone, Default, Serialize, Deserialize)] pub struct BinData { /// Binary data items (BinaryData0, BinaryData1, etc.) pub items: Vec<BinaryDataItem>, } /// Binary data item #[derive(Debug, Clone, Default, Serialize, Deserialize)] pub struct BinaryDataItem { /// Item index pub index: WORD, /// Base64 encoded data or file path / Base64로 인코딩된 데이터 또는 파일 경로 pub data: String, } impl BinData { /// Parse BinData storage from CFB structure /// CFB 구조에서 BinData 스토리지를 파싱합니다. /// /// # Arguments /// * `cfb` - CompoundFile structure (mutable reference required) / CompoundFile 구조체 (가변 참조 필요) /// * `output_format` - Output format for binary data / 바이너리 데이터 출력 형식 /// * `bin_data_records` - BinData records from DocInfo (표 17) / DocInfo의 BinData 레코드 (표 17) /// /// # Returns /// Parsed BinData structure / 파싱된 BinData 구조체 /// /// # Notes /// 표 17의 HWPTAG_BIN_DATA 레코드에서 EMBEDDING 타입인 경우 `binary_data_id`와 `extension` 정보를 사용합니다. /// When BinDataRecord type is EMBEDDING, we use `binary_data_id` and `extension` from Table 17. pub fn parse( cfb: &mut CompoundFile<Cursor<&[u8]>>, output_format: BinaryDataFormat, bin_data_records: &[BinDataRecord], ) -> Result<Self, HwpError> { let mut items = Vec::new(); // 표 17의 bin_data_records를 사용하여 스트림을 찾습니다 (EMBEDDING/STORAGE 타입만) // Use bin_data_records from Table 17 to find streams (only EMBEDDING/STORAGE types) for record in bin_data_records { let (binary_data_id, extension_opt) = match record { BinDataRecord::Embedding { embedding, .. } => { (embedding.binary_data_id, Some(embedding.extension.clone())) } BinDataRecord::Storage { storage, .. } => (storage.binary_data_id, None), BinDataRecord::Link { .. } => { // LINK 타입은 BinData 스토리지에 없으므로 건너뜀 // LINK type is not in BinData storage, so skip continue; } }; let base_stream_name = format!("BIN{:04X}", binary_data_id); // Try different path formats // 다양한 경로 형식 시도 let mut paths = vec![ format!("BinData/{}", base_stream_name), format!("Root Entry/BinData/{}", base_stream_name), base_stream_name.clone(), ]; // 표 17의 extension 정보가 있으면 확장자 포함 경로도 시도 // If extension info from Table 17 exists, also try paths with extension if let Some(ext) = &extension_opt { paths.push(format!("BinData/{}.{}", base_stream_name, ext)); paths.push(format!("Root Entry/BinData/{}.{}", base_stream_name, ext)); } let mut found = false; for path in &paths { match cfb.open_stream(path) { Ok(mut stream) => { let mut buffer = Vec::new(); match stream.read_to_end(&mut buffer) { Ok(_) => { if !buffer.is_empty() { // BinData 스트림은 압축되어 있으므로 압축 해제 필요 // BinData streams are compressed, so decompression is required // 레거시 코드 참고: hwpjs.js는 pako.inflate(..., { windowBits: -15 }) // pyhwp는 zlib.decompress(..., -15) 사용 // Reference: hwpjs.js uses pako.inflate(..., { windowBits: -15 }) // pyhwp uses zlib.decompress(..., -15) let _compressed_size = buffer.len(); let decompressed_buffer = match decompress_deflate(&buffer) { Ok(decompressed) => decompressed, Err(e) => { #[cfg(debug_assertions)] eprintln!( "Warning: Failed to decompress BinData stream '{}' (id={}): {}. Using raw data.", path, binary_data_id, e ); buffer.clone() // 압축 해제 실패 시 원본 데이터 사용 } }; let data = match &output_format { BinaryDataFormat::Base64 => { STANDARD.encode(&decompressed_buffer) } BinaryDataFormat::File(dir_path) => { let ext = extension_opt.as_deref().unwrap_or("bin"); let file_name = format!("{}.{}", base_stream_name, ext); let file_path = Path::new(dir_path).join(&file_name); std::fs::create_dir_all(dir_path).map_err(\|e\| { format!( "Failed to create directory '{}': {}", dir_path, e ) })?; std::fs::write(&file_path, &decompressed_buffer) .map_err(\|e\| { format!( "Failed to write file '{}': {}", file_path.display(), e ) })?; file_path.to_string_lossy().to_string() } }; items.push(BinaryDataItem { index: binary_data_id, data, }); found = true; break; } } Err(_) => continue, } } Err(_) => continue, } } if !found { // 스트림을 찾지 못했지만 계속 진행 (다른 레코드는 있을 수 있음) // Stream not found, but continue (other records may exist) } } Ok(BinData { items }) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/fileheader/serialize.rs	crates/hwp-core/src/document/fileheader/serialize.rs	use crate::types::DWORD; use serde::Serializer; use super::constants::{document_flags, license_flags}; /// Serialize version DWORD as "M.n.P.r" format string pub fn serialize_version<S>(version: &DWORD, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, { serializer.serialize_str(&format_version(version)) } /// Format version DWORD to "M.n.P.r" string /// Format: 0xMMnnPPrr (e.g., 0x05000300 = "5.0.3.0") fn format_version(version: DWORD) -> String { let major = (version >> 24) & 0xFF; let minor = (version >> 16) & 0xFF; let patch = (version >> 8) & 0xFF; let revision = version & 0xFF; format!("{}.{}.{}.{}", major, minor, patch, revision) } /// Serialize document_flags DWORD as array of flag constants pub fn serialize_document_flags<S>(flags: &DWORD, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, { use serde::ser::SerializeSeq; let mut active_flags = Vec::new(); if (flags & 0x01) != 0 { active_flags.push(document_flags::COMPRESSED); } if (flags & 0x02) != 0 { active_flags.push(document_flags::ENCRYPTED); } if (flags & 0x04) != 0 { active_flags.push(document_flags::DISTRIBUTION); } if (flags & 0x08) != 0 { active_flags.push(document_flags::SCRIPT); } if (flags & 0x10) != 0 { active_flags.push(document_flags::DRM); } if (flags & 0x20) != 0 { active_flags.push(document_flags::XML_TEMPLATE); } if (flags & 0x40) != 0 { active_flags.push(document_flags::HISTORY); } if (flags & 0x80) != 0 { active_flags.push(document_flags::ELECTRONIC_SIGNATURE); } if (flags & 0x100) != 0 { active_flags.push(document_flags::CERTIFICATE_ENCRYPTION); } if (flags & 0x200) != 0 { active_flags.push(document_flags::SIGNATURE_PREVIEW); } if (flags & 0x400) != 0 { active_flags.push(document_flags::CERTIFICATE_DRM); } if (flags & 0x800) != 0 { active_flags.push(document_flags::CCL); } if (flags & 0x1000) != 0 { active_flags.push(document_flags::MOBILE_OPTIMIZED); } if (flags & 0x2000) != 0 { active_flags.push(document_flags::PRIVACY_SECURITY); } if (flags & 0x4000) != 0 { active_flags.push(document_flags::TRACK_CHANGE); } if (flags & 0x8000) != 0 { active_flags.push(document_flags::KOGL); } if (flags & 0x10000) != 0 { active_flags.push(document_flags::VIDEO_CONTROL); } if (flags & 0x20000) != 0 { active_flags.push(document_flags::TABLE_OF_CONTENTS); } let mut seq = serializer.serialize_seq(Some(active_flags.len()))?; for flag in active_flags { seq.serialize_element(flag)?; } seq.end() } /// Serialize license_flags DWORD as array of flag constants pub fn serialize_license_flags<S>(flags: &DWORD, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, { use serde::ser::SerializeSeq; let mut active_flags = Vec::new(); if (flags & 0x01) != 0 { active_flags.push(license_flags::CCL_KOGL); } if (flags & 0x02) != 0 { active_flags.push(license_flags::COPY_RESTRICTED); } if (flags & 0x04) != 0 { active_flags.push(license_flags::COPY_ALLOWED_SAME_CONDITION); } let mut seq = serializer.serialize_seq(Some(active_flags.len()))?; for flag in active_flags { seq.serialize_element(flag)?; } seq.end() }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/fileheader/mod.rs	crates/hwp-core/src/document/fileheader/mod.rs	/// FileHeader parsing module /// /// This module handles parsing of HWP FileHeader structure. /// According to HWP 5.0 spec, FileHeader is 256 bytes. /// /// 스펙 문서 매핑: 표 2 - 파일 인식 정보 (FileHeader 스트림) use crate::error::HwpError; use crate::types::{BYTE, DWORD}; use serde::{Deserialize, Serialize}; mod constants; mod serialize; use serialize::{serialize_document_flags, serialize_license_flags, serialize_version}; /// FileHeader structure for HWP 5.0 #[derive(Debug, Clone, Serialize, Deserialize)] pub struct FileHeader { /// Signature: "HWP Document File" (32 bytes) pub signature: String, /// File version (4 bytes, DWORD) /// Format: 0xMMnnPPrr (e.g., 0x05000300 = 5.0.3.0) #[serde(serialize_with = "serialize_version")] pub version: DWORD, /// Document flags (4 bytes, DWORD) /// Bit flags: compression, encryption, distribution, script, DRM, electronic signature, etc. #[serde(serialize_with = "serialize_document_flags")] pub document_flags: DWORD, /// License flags (4 bytes, DWORD) /// Bit flags: CCL, KOGL license, copy restriction, etc. #[serde(serialize_with = "serialize_license_flags")] pub license_flags: DWORD, /// Encryption version (4 bytes, DWORD) pub encrypt_version: DWORD, /// KOGL license country (1 byte, BYTE) pub kogl_country: BYTE, /// Reserved (207 bytes) - excluded from JSON serialization #[serde(skip_serializing)] pub reserved: Vec<u8>, } impl FileHeader { /// Parse FileHeader from byte array /// /// # Arguments /// * `data` - 256-byte FileHeader data /// /// # Returns /// Parsed FileHeader structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 256 { return Err(HwpError::insufficient_data("FileHeader", 256, data.len())); } // Parse signature (32 bytes) let signature_bytes = &data[0..32]; let signature = String::from_utf8_lossy(signature_bytes) .trim_end_matches('\0') .to_string(); // Validate signature if signature != "HWP Document File" { return Err(HwpError::InvalidSignature { found: signature }); } // Parse version (4 bytes, DWORD, little-endian) let version = DWORD::from_le_bytes([data[32], data[33], data[34], data[35]]); // Parse document_flags (4 bytes, DWORD, little-endian) let document_flags = DWORD::from_le_bytes([data[36], data[37], data[38], data[39]]); // Parse license_flags (4 bytes, DWORD, little-endian) let license_flags = DWORD::from_le_bytes([data[40], data[41], data[42], data[43]]); // Parse encrypt_version (4 bytes, DWORD, little-endian) let encrypt_version = DWORD::from_le_bytes([data[44], data[45], data[46], data[47]]); // Parse kogl_country (1 byte, BYTE) let kogl_country = data[48]; // Parse reserved (207 bytes) let reserved = data[49..256].to_vec(); Ok(FileHeader { signature, version, document_flags, license_flags, encrypt_version, kogl_country, reserved, }) } /// Check if file is compressed pub fn is_compressed(&self) -> bool { (self.document_flags & 0x01) != 0 } /// Check if file is encrypted pub fn is_encrypted(&self) -> bool { (self.document_flags & 0x02) != 0 } /// Check if XMLTemplate storage exists /// XMLTemplate 스토리지 존재 여부 확인 pub fn has_xml_template(&self) -> bool { (self.document_flags & 0x20) != 0 // Bit 5 } /// Convert FileHeader to JSON string pub fn to_json(&self) -> Result<String, HwpError> { serde_json::to_string_pretty(self).map_err(HwpError::from) } /// Get version as string (e.g., "5.0.3.0") pub fn version_string(&self) -> String { let major = (self.version >> 24) & 0xFF; let minor = (self.version >> 16) & 0xFF; let patch = (self.version >> 8) & 0xFF; let revision = self.version & 0xFF; format!("{}.{}.{}.{}", major, minor, patch, revision) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/fileheader/constants.rs	crates/hwp-core/src/document/fileheader/constants.rs	/// Document flag constants /// /// 스펙 문서 매핑: 표 3 - 속성 (첫 번째 DWORD) pub mod document_flags { /// Bit 0: 압축 여부 pub const COMPRESSED: &str = "compressed"; /// Bit 1: 암호 설정 여부 pub const ENCRYPTED: &str = "encrypted"; /// Bit 2: 배포용 문서 여부 pub const DISTRIBUTION: &str = "distribution"; /// Bit 3: 스크립트 저장 여부 pub const SCRIPT: &str = "script"; /// Bit 4: DRM 보안 문서 여부 pub const DRM: &str = "drm"; /// Bit 5: XMLTemplate 스토리지 존재 여부 pub const XML_TEMPLATE: &str = "xml_template"; /// Bit 6: 문서 이력 관리 존재 여부 pub const HISTORY: &str = "history"; /// Bit 7: 전자 서명 정보 존재 여부 pub const ELECTRONIC_SIGNATURE: &str = "electronic_signature"; /// Bit 8: 공인 인증서 암호화 여부 pub const CERTIFICATE_ENCRYPTION: &str = "certificate_encryption"; /// Bit 9: 전자 서명 예비 저장 여부 pub const SIGNATURE_PREVIEW: &str = "signature_preview"; /// Bit 10: 공인 인증서 DRM 보안 문서 여부 pub const CERTIFICATE_DRM: &str = "certificate_drm"; /// Bit 11: CCL 문서 여부 pub const CCL: &str = "ccl"; /// Bit 12: 모바일 최적화 여부 pub const MOBILE_OPTIMIZED: &str = "mobile_optimized"; /// Bit 13: 개인 정보 보안 문서 여부 pub const PRIVACY_SECURITY: &str = "privacy_security"; /// Bit 14: 변경 추적 문서 여부 pub const TRACK_CHANGE: &str = "track_change"; /// Bit 15: 공공누리(KOGL) 저작권 문서 pub const KOGL: &str = "kogl"; /// Bit 16: 비디오 컨트롤 포함 여부 pub const VIDEO_CONTROL: &str = "video_control"; /// Bit 17: 차례 필드 컨트롤 포함 여부 pub const TABLE_OF_CONTENTS: &str = "table_of_contents"; } /// License flag constants /// /// 스펙 문서 매핑: 표 3 - 속성 (두 번째 DWORD) pub mod license_flags { /// Bit 0: CCL, 공공누리 라이선스 정보 pub const CCL_KOGL: &str = "ccl_kogl"; /// Bit 1: 복제 제한 여부 pub const COPY_RESTRICTED: &str = "copy_restricted"; /// Bit 2: 동일 조건 하에 복제 허가 여부 (복제 제한인 경우 무시) pub const COPY_ALLOWED_SAME_CONDITION: &str = "copy_allowed_same_condition"; }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/tests/parser_tests.rs	crates/hwp-core/tests/parser_tests.rs	/// HwpParser 테스트 /// HwpParser tests mod common; use hwp_core::*; #[test] fn test_hwp_parser_new() { let _parser = HwpParser::new(); } #[test] fn test_hwp_parser_parse_with_actual_file() { // Test with actual HWP file if available use crate::common::find_fixture_file; if let Some(path) = find_fixture_file("noori.hwp") { if let Ok(data) = std::fs::read(path) { let parser = HwpParser::new(); let result = parser.parse(&data); if let Err(e) = &result { eprintln!("Parse error: {}", e); } assert!(result.is_ok(), "Should parse actual HWP file"); let document = result.unwrap(); // Validate document structure assert_eq!( document.file_header.signature.trim_end_matches('\0'), "HWP Document File" ); assert!(document.file_header.version > 0); } } } #[test] fn test_hwp_parser_parse_fileheader_json() { // Test FileHeader JSON output use crate::common::find_fixture_file; if let Some(path) = find_fixture_file("noori.hwp") { if let Ok(data) = std::fs::read(path) { let parser = HwpParser::new(); let result = parser.parse_fileheader_json(&data); assert!(result.is_ok(), "Should return FileHeader as JSON"); let json = result.unwrap(); // Validate JSON contains expected fields assert!(json.contains("signature")); assert!(json.contains("version")); assert!(json.contains("document_flags")); assert!(json.contains("license_flags")); assert!(json.contains("encrypt_version")); assert!(json.contains("kogl_country")); } } } #[test] fn test_hwp_parser_parse_with_invalid_data() { let parser = HwpParser::new(); let data = b"invalid hwp file content"; let result = parser.parse(data); // Should fail because it's not a valid CFB structure assert!(result.is_err(), "Should fail for invalid CFB data"); }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/tests/fileheader_tests.rs	crates/hwp-core/tests/fileheader_tests.rs	/// FileHeader 파싱 테스트 /// FileHeader parsing tests mod common; use hwp_core::*; #[test] fn test_fileheader_parse_basic() { // Create a minimal valid FileHeader let mut data = vec![0u8; 256]; // Set signature "HWP Document File" let signature = b"HWP Document File\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"; data[0..signature.len()].copy_from_slice(signature); // Set version (5.0.3.0 = 0x05000300) data[32..36].copy_from_slice(&0x05000300u32.to_le_bytes()); // Set document_flags (compressed flag) data[36..40].copy_from_slice(&0x01u32.to_le_bytes()); let fileheader = FileHeader::parse(&data).expect("Should parse FileHeader"); assert_eq!( fileheader.signature.trim_end_matches('\0'), "HWP Document File" ); assert_eq!(fileheader.version, 0x05000300); assert!(fileheader.is_compressed()); } #[test] fn test_fileheader_parse_too_short() { let data = vec![0u8; 100]; let result = FileHeader::parse(&data); assert!( result.is_err(), "Should fail for data shorter than 256 bytes" ); } #[test] fn test_fileheader_parse_from_actual_file() { // Test with actual HWP file if available use crate::common::find_fixture_file; let file_path = match find_fixture_file("noori.hwp") { Some(p) => p, None => { println!("HWP test file not found in fixtures directory"); return; } }; match std::fs::read(file_path) { Ok(data) => { let mut cfb = CfbParser::parse(&data).expect("Should parse CFB"); match CfbParser::read_stream(&mut cfb, "FileHeader") { Ok(fileheader_data) => { let fileheader = FileHeader::parse(&fileheader_data) .expect("Should parse FileHeader from actual file"); // Validate signature (must be exactly "HWP Document File") let signature_trimmed = fileheader.signature.trim_end_matches('\0'); assert_eq!( signature_trimmed, "HWP Document File", "Signature must be 'HWP Document File'" ); // Validate signature bytes (original data should be 32 bytes) // The signature field is a String, but we check the original bytes let signature_bytes = &fileheader_data[0..32]; assert_eq!( signature_bytes.len(), 32, "Signature bytes must be exactly 32 bytes" ); let signature_str = String::from_utf8_lossy(signature_bytes) .trim_end_matches('\0') .to_string(); assert_eq!( signature_str, "HWP Document File", "Signature content must be 'HWP Document File'" ); // Validate version format (0xMMnnPPrr) // MM should be 5 for HWP 5.0 let major = (fileheader.version >> 24) & 0xFF; let minor = (fileheader.version >> 16) & 0xFF; let patch = (fileheader.version >> 8) & 0xFF; let revision = fileheader.version & 0xFF; assert_eq!(major, 5, "Major version should be 5 for HWP 5.0"); assert!( minor <= 0xFF && patch <= 0xFF && revision <= 0xFF, "Version components should be valid (0-255)" ); // Validate document_flags (check bit flags) // Bit 0: 압축 여부 let is_compressed = (fileheader.document_flags & 0x01) != 0; assert_eq!( is_compressed, fileheader.is_compressed(), "is_compressed() should match bit 0" ); // Bit 1: 암호 설정 여부 let is_encrypted = (fileheader.document_flags & 0x02) != 0; assert_eq!( is_encrypted, fileheader.is_encrypted(), "is_encrypted() should match bit 1" ); // Validate EncryptVersion (should be 0-4 according to spec) assert!( fileheader.encrypt_version <= 4, "EncryptVersion should be 0-4, got {}", fileheader.encrypt_version ); // Validate KOGL Country (should be 0, 6, or 15 according to spec) // Valid values: 0 (Not set), 6 (KOR), 15 (US) assert!( fileheader.kogl_country == 0 \|\| fileheader.kogl_country == 6 \|\| fileheader.kogl_country == 15, "KOGL Country should be 0, 6, or 15, got {}", fileheader.kogl_country ); // Validate reserved field (should be exactly 207 bytes) assert_eq!( fileheader.reserved.len(), 207, "Reserved field must be exactly 207 bytes, got {}", fileheader.reserved.len() ); // Validate total structure size let total_size = 32 // signature + 4 // version + 4 // document_flags + 4 // license_flags + 4 // encrypt_version + 1 // kogl_country + 207; // reserved assert_eq!(total_size, 256, "Total FileHeader size should be 256 bytes"); } Err(e) => { panic!("Should be able to read FileHeader stream: {}", e); } } } Err(_) => { // Skip test if file not available } } } #[test] fn test_fileheader_is_compressed() { let mut data = vec![0u8; 256]; let signature = b"HWP Document File\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"; data[0..signature.len()].copy_from_slice(signature); data[32..36].copy_from_slice(&0x05000300u32.to_le_bytes()); // Test with compression flag set data[36..40].copy_from_slice(&0x01u32.to_le_bytes()); let fileheader = FileHeader::parse(&data).unwrap(); assert!(fileheader.is_compressed()); // Test without compression flag data[36..40].copy_from_slice(&0x00u32.to_le_bytes()); let fileheader = FileHeader::parse(&data).unwrap(); assert!(!fileheader.is_compressed()); } #[test] fn test_fileheader_is_encrypted() { let mut data = vec![0u8; 256]; let signature = b"HWP Document File\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"; data[0..signature.len()].copy_from_slice(signature); data[32..36].copy_from_slice(&0x05000300u32.to_le_bytes()); // Test with encryption flag set data[36..40].copy_from_slice(&0x02u32.to_le_bytes()); let fileheader = FileHeader::parse(&data).unwrap(); assert!(fileheader.is_encrypted()); // Test without encryption flag data[36..40].copy_from_slice(&0x00u32.to_le_bytes()); let fileheader = FileHeader::parse(&data).unwrap(); assert!(!fileheader.is_encrypted()); }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/tests/common.rs	crates/hwp-core/tests/common.rs	/// 공통 테스트 헬퍼 함수들 /// Common test helper functions use std::path::PathBuf; /// Helper function to find test HWP files directory pub fn find_fixtures_dir() -> Option<PathBuf> { let manifest_dir = std::env::var("CARGO_MANIFEST_DIR") .ok() .map(PathBuf::from) .unwrap_or_else(\|\| std::path::PathBuf::from(".")); let fixtures_path = manifest_dir.join("tests").join("fixtures"); if fixtures_path.exists() && fixtures_path.is_dir() { return Some(fixtures_path); } // Fallback for backward compatibility let possible_paths = ["tests/fixtures", "./tests/fixtures"]; for path_str in &possible_paths { let path = std::path::Path::new(path_str); if path.exists() && path.is_dir() { return Some(path.to_path_buf()); } } None } /// Helper function to find test HWP file (for snapshot tests, uses noori.hwp) pub fn find_test_file() -> Option<String> { if let Some(dir) = find_fixtures_dir() { let file_path = dir.join("noori.hwp"); if file_path.exists() { return Some(file_path.to_string_lossy().to_string()); } } None } /// Helper function to find headerfooter.hwp file pub fn find_headerfooter_file() -> Option<String> { if let Some(dir) = find_fixtures_dir() { let file_path = dir.join("headerfooter.hwp"); if file_path.exists() { return Some(file_path.to_string_lossy().to_string()); } } None } /// Helper function to get all HWP files in fixtures directory pub fn find_all_hwp_files() -> Vec<String> { if let Some(dir) = find_fixtures_dir() { let mut files = Vec::new(); if let Ok(entries) = std::fs::read_dir(&dir) { for entry in entries.flatten() { let path = entry.path(); if path.is_file() && path.extension().and_then(\|s\| s.to_str()) == Some("hwp") { if let Some(path_str) = path.to_str() { files.push(path_str.to_string()); } } } } files.sort(); return files; } Vec::new() } /// Helper function to find a specific HWP file in fixtures directory pub fn find_fixture_file(filename: &str) -> Option<String> { if let Some(dir) = find_fixtures_dir() { let file_path = dir.join(filename); if file_path.exists() { return Some(file_path.to_string_lossy().to_string()); } } None }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/tests/cfb_tests.rs	crates/hwp-core/tests/cfb_tests.rs	/// CFB 파서 테스트 /// CFB parser tests mod common; use hwp_core::*; use std::fs; #[test] fn test_cfb_parse_basic() { // Test with actual HWP file from fixtures directory use crate::common::find_fixture_file; if let Some(path) = find_fixture_file("noori.hwp") { if let Ok(data) = fs::read(path) { let result = CfbParser::parse(&data); assert!( result.is_ok(), "CFB parsing should succeed for valid HWP file" ); } } } #[test] fn test_cfb_read_fileheader() { // Test reading FileHeader stream from CFB use crate::common::find_fixture_file; if let Some(path) = find_fixture_file("noori.hwp") { if let Ok(data) = fs::read(path) { let mut cfb = CfbParser::parse(&data).expect("Should parse CFB"); let result = CfbParser::read_stream(&mut cfb, "FileHeader"); assert!(result.is_ok(), "Should be able to read FileHeader stream"); let fileheader = result.unwrap(); assert!(!fileheader.is_empty(), "FileHeader should not be empty"); assert_eq!(fileheader.len(), 256, "FileHeader should be 256 bytes"); } } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/tests/decompress_tests.rs	crates/hwp-core/tests/decompress_tests.rs	/// 압축 해제 테스트 /// Decompression tests use hwp_core::*; #[test] fn test_decompress_zlib_basic() { // Create a simple test: compress "hello" using zlib format and then decompress it use flate2::write::ZlibEncoder; use flate2::Compression; use std::io::Write; let original = b"hello world"; let mut encoder = ZlibEncoder::new(Vec::new(), Compression::default()); encoder.write_all(original).unwrap(); let compressed = encoder.finish().unwrap(); let decompressed = decompress_zlib(&compressed).expect("Should decompress"); assert_eq!( decompressed, original, "Decompressed data should match original" ); } #[test] fn test_decompress_zlib_empty() { // Empty data should still work (though it might error, which is fine) let result = decompress_zlib(b""); // Either Ok with empty vec or Err is acceptable if let Ok(data) = result { assert!(data.is_empty() \|\| !data.is_empty()); } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/tests/snapshot_tests.rs	crates/hwp-core/tests/snapshot_tests.rs	/// 스냅샷 테스트 /// Snapshot tests mod common; use common::; use hwp_core::; use hwp_core::document::ParagraphRecord; use insta::{assert_snapshot, with_settings}; // insta가 tests/snapshots 디렉토리를 사용하도록 설정하는 헬퍼 매크로 macro_rules! assert_snapshot_with_path { ($name:expr, $value:expr) => { let manifest_dir = env!("CARGO_MANIFEST_DIR"); let snapshots_dir = std::path::Path::new(manifest_dir) .join("tests") .join("snapshots"); with_settings!({ snapshot_path => snapshots_dir }, { assert_snapshot!($name, $value); }); }; } #[test] fn test_full_document_json_snapshot() { let file_path = match find_test_file() { Some(path) => path, None => return, // Skip test if file not available }; // 파일명에서 스냅샷 이름 추출 / Extract snapshot name from filename let file_name = std::path::Path::new(&file_path) .file_stem() .and_then(\|n\| n.to_str()) .unwrap_or("unknown"); let snapshot_name = file_name.replace(['-', '.'], "_"); let snapshot_name_json = format!("{}_json", snapshot_name); if let Ok(data) = std::fs::read(&file_path) { let parser = HwpParser::new(); let result = parser.parse(&data); if let Err(e) = &result { eprintln!("Parse error: {:?}", e); } assert!(result.is_ok(), "Should parse HWP document"); let document = result.unwrap(); // Verify BodyText is parsed correctly // BodyText가 올바르게 파싱되었는지 검증 assert!( !document.body_text.sections.is_empty(), "BodyText should have at least one section" ); assert!( document.body_text.sections[0].index == 0, "First section should have index 0" ); assert!( !document.body_text.sections[0].paragraphs.is_empty(), "First section should have at least one paragraph" ); // Convert to JSON // serde_json already outputs unicode characters as-is (not escaped) // Only control characters are escaped according to JSON standard let json = serde_json::to_string_pretty(&document).expect("Should serialize document to JSON"); assert_snapshot_with_path!(snapshot_name_json.as_str(), json); // 실제 JSON 파일로도 저장 / Also save as actual JSON file let manifest_dir = env!("CARGO_MANIFEST_DIR"); let snapshots_dir = std::path::Path::new(manifest_dir) .join("tests") .join("snapshots"); std::fs::create_dir_all(&snapshots_dir).unwrap_or(()); let json_file = snapshots_dir.join(format!("{}.json", file_name)); std::fs::write(&json_file, &json).unwrap_or_else(\|e\| { eprintln!("Failed to write JSON file: {}", e); }); } } #[test] fn test_all_fixtures_json_snapshots() { // 모든 fixtures 파일에 대해 JSON 스냅샷 생성 / Generate JSON snapshots for all fixtures files let hwp_files = find_all_hwp_files(); if hwp_files.is_empty() { println!("No HWP files found in fixtures directory"); return; } let parser = HwpParser::new(); let manifest_dir = env!("CARGO_MANIFEST_DIR"); let snapshots_dir = std::path::Path::new(manifest_dir) .join("tests") .join("snapshots"); for file_path in &hwp_files { let file_name = std::path::Path::new(file_path) .file_stem() .and_then(\|n\| n.to_str()) .unwrap_or("unknown"); // 파일명을 스냅샷 이름으로 사용 (특수 문자 제거) / Use filename as snapshot name (remove special chars) let snapshot_name = file_name.replace(['-', '.'], "_"); let snapshot_name_json = format!("{}_json", snapshot_name); match std::fs::read(file_path) { Ok(data) => { match parser.parse(&data) { Ok(document) => { // Convert to JSON let json = serde_json::to_string_pretty(&document) .expect("Should serialize document to JSON"); // 스냅샷 생성 / Create snapshot assert_snapshot_with_path!(snapshot_name_json.as_str(), json); // 실제 JSON 파일로도 저장 / Also save as actual JSON file let json_file = snapshots_dir.join(format!("{}.json", file_name)); std::fs::create_dir_all(&snapshots_dir).unwrap_or(()); std::fs::write(&json_file, &json).unwrap_or_else(\|e\| { eprintln!("Failed to write JSON file {}: {}", json_file.display(), e); }); } Err(e) => { eprintln!("Skipping {} due to parse error: {}", file_name, e); } } } Err(e) => { eprintln!("Failed to read {}: {}", file_name, e); } } } } #[test] fn test_debug_record_levels() { let file_path = match find_test_file() { Some(path) => path, None => return, }; if let Ok(data) = std::fs::read(&file_path) { let mut cfb = CfbParser::parse(&data).expect("Should parse CFB"); let fileheader = FileHeader::parse( &CfbParser::read_stream(&mut cfb, "FileHeader").expect("Should read FileHeader"), ) .expect("Should parse FileHeader"); let section_data = CfbParser::read_nested_stream(&mut cfb, "BodyText", "Section0") .expect("Should read Section0"); let decompressed = if fileheader.is_compressed() { hwp_core::decompress_deflate(&section_data).expect("Should decompress section data") } else { section_data }; let mut offset = 0; let mut record_count = 0; let mut table_records = Vec::new(); let mut list_header_records = Vec::new(); while offset < decompressed.len() { let remaining_data = &decompressed[offset..]; match RecordHeader::parse(remaining_data) { Ok((header, header_size)) => { record_count += 1; let tag_id = header.tag_id; let level = header.level; let size = header.size as usize; if tag_id == 0x43 { table_records.push((record_count, level, offset)); println!( "Record {}: TABLE (0x43) at offset {}, level {}", record_count, offset, level ); } if tag_id == 0x44 { list_header_records.push((record_count, level, offset)); println!( "Record {}: LIST_HEADER (0x44) at offset {}, level {}", record_count, offset, level ); } offset += header_size + size; } Err(_) => break, } } println!("\n=== Summary ==="); println!("Total records: {}", record_count); println!("TABLE records: {}", table_records.len()); println!("LIST_HEADER records: {}", list_header_records.len()); for (table_idx, table_level, table_offset) in &table_records { println!( "\nTABLE at record {} (offset {}, level {}):", table_idx, table_offset, table_level ); for (list_idx, list_level, list_offset) in &list_header_records { if list_offset > table_offset && list_offset < table_offset + 1000 { println!( " -> LIST_HEADER at record {} (offset {}, level {})", list_idx, list_offset, list_level ); } } } } } #[test] fn test_debug_list_header_children() { let file_path = match find_test_file() { Some(path) => path, None => return, }; if let Ok(data) = std::fs::read(&file_path) { let parser = HwpParser::new(); let result = parser.parse(&data); if let Err(e) = &result { eprintln!("Parse error: {:?}", e); } assert!(result.is_ok(), "Should parse HWP document"); let _document = result.unwrap(); use hwp_core::decompress::decompress_deflate; use hwp_core::document::bodytext::record_tree::RecordTreeNode; use hwp_core::CfbParser; use hwp_core::FileHeader; let mut cfb = CfbParser::parse(&data).expect("Should parse CFB"); let fileheader = FileHeader::parse( &CfbParser::read_stream(&mut cfb, "FileHeader").expect("Should read FileHeader"), ) .expect("Should parse FileHeader"); let section_data = CfbParser::read_nested_stream(&mut cfb, "BodyText", "Section0") .expect("Should read Section0"); let decompressed = if fileheader.is_compressed() { decompress_deflate(&section_data).expect("Should decompress section data") } else { section_data }; let tree = RecordTreeNode::parse_tree(&decompressed).expect("Should parse tree"); // LIST_HEADER 찾기 및 자식 확인 / Find LIST_HEADER and check children fn find_list_headers(node: &RecordTreeNode, depth: usize) { if node.tag_id() == 0x44 { // HWPTAG_LIST_HEADER println!( "{}LIST_HEADER (level {}): {} children", " ".repeat(depth), node.level(), node.children().len() ); for (i, child) in node.children().iter().enumerate() { println!( "{} Child {}: tag_id={}, level={}", " ".repeat(depth), i, child.tag_id(), child.level() ); if child.tag_id() == 0x32 { // HWPTAG_PARA_HEADER println!("{} -> PARA_HEADER found!", " ".repeat(depth)); } } } for child in node.children() { find_list_headers(child, depth + 1); } } println!("=== LIST_HEADER Children Debug ==="); find_list_headers(&tree, 0); } } #[test] fn test_document_markdown_snapshot() { let file_path = match find_test_file() { Some(path) => path, None => return, // Skip test if file not available }; // 파일명에서 스냅샷 이름 추출 / Extract snapshot name from filename let file_name = std::path::Path::new(&file_path) .file_stem() .and_then(\|n\| n.to_str()) .unwrap_or("unknown"); let snapshot_name = file_name.replace(['-', '.'], "_"); let snapshot_name_md = format!("{}_markdown", snapshot_name); if let Ok(data) = std::fs::read(&file_path) { let parser = HwpParser::new(); let result = parser.parse(&data); if let Err(e) = &result { eprintln!("Parse error: {:?}", e); } assert!(result.is_ok(), "Should parse HWP document"); let document = result.unwrap(); // Convert to markdown with image files (not base64) // 이미지를 파일로 저장하고 파일 경로를 사용 / Save images as files and use file paths let manifest_dir = env!("CARGO_MANIFEST_DIR"); let snapshots_dir = std::path::Path::new(manifest_dir) .join("tests") .join("snapshots"); let images_dir = snapshots_dir.join("images").join(file_name); std::fs::create_dir_all(&images_dir).unwrap_or(()); let options = hwp_core::viewer::markdown::MarkdownOptions { image_output_dir: images_dir.to_str().map(\|s\| s.to_string()), use_html: Some(true), include_version: Some(true), include_page_info: Some(true), }; let markdown = document.to_markdown(&options); assert_snapshot_with_path!(snapshot_name_md.as_str(), markdown); // 실제 Markdown 파일로도 저장 / Also save as actual Markdown file let md_file = snapshots_dir.join(format!("{}.md", file_name)); std::fs::write(&md_file, &markdown).unwrap_or_else(\|e\| { eprintln!("Failed to write Markdown file: {}", e); }); } } #[test] fn test_headerfooter_markdown() { // headerfooter.hwp 파일에 대해 Markdown 스냅샷 생성 / Generate Markdown snapshot for headerfooter.hwp let file_path = match find_headerfooter_file() { Some(path) => path, None => { eprintln!("headerfooter.hwp not found, skipping test"); return; } }; let parser = HwpParser::new(); let manifest_dir = env!("CARGO_MANIFEST_DIR"); let snapshots_dir = std::path::Path::new(manifest_dir) .join("tests") .join("snapshots"); let file_name = std::path::Path::new(&file_path) .file_stem() .and_then(\|n\| n.to_str()) .unwrap_or("unknown"); let snapshot_name = file_name.replace(['-', '.'], "_"); let snapshot_name_md = format!("{}_markdown", snapshot_name); match std::fs::read(&file_path) { Ok(data) => { match parser.parse(&data) { Ok(document) => { // Convert to markdown with image files (not base64) // 이미지를 파일로 저장하고 파일 경로를 사용 / Save images as files and use file paths let images_dir = snapshots_dir.join("images").join(file_name); std::fs::create_dir_all(&images_dir).unwrap_or(()); let options = hwp_core::viewer::markdown::MarkdownOptions { image_output_dir: images_dir.to_str().map(\|s\| s.to_string()), use_html: Some(true), include_version: Some(true), include_page_info: Some(true), }; let markdown = document.to_markdown(&options); // 스냅샷 생성 / Create snapshot assert_snapshot_with_path!(snapshot_name_md.as_str(), markdown); // 실제 Markdown 파일로도 저장 / Also save as actual Markdown file let md_file = snapshots_dir.join(format!("{}.md", file_name)); std::fs::create_dir_all(&snapshots_dir).unwrap_or(()); std::fs::write(&md_file, &markdown).unwrap_or_else(\|e\| { eprintln!("Failed to write Markdown file {}: {}", md_file.display(), e); }); } Err(e) => { eprintln!("Failed to parse {}: {:?}", file_path, e); } } } Err(e) => { eprintln!("Failed to read {}: {}", file_path, e); } } } #[test] fn test_all_fixtures_markdown_snapshots() { // 모든 fixtures 파일에 대해 Markdown 스냅샷 생성 / Generate Markdown snapshots for all fixtures files let hwp_files = find_all_hwp_files(); if hwp_files.is_empty() { println!("No HWP files found in fixtures directory"); return; } let parser = HwpParser::new(); let manifest_dir = env!("CARGO_MANIFEST_DIR"); let snapshots_dir = std::path::Path::new(manifest_dir) .join("tests") .join("snapshots"); for file_path in &hwp_files { let file_name = std::path::Path::new(file_path) .file_stem() .and_then(\|n\| n.to_str()) .unwrap_or("unknown"); // 파일명을 스냅샷 이름으로 사용 (특수 문자 제거) / Use filename as snapshot name (remove special chars) let snapshot_name = file_name.replace(['-', '.'], "_"); let snapshot_name_md = format!("{}_markdown", snapshot_name); match std::fs::read(file_path) { Ok(data) => { match parser.parse(&data) { Ok(document) => { // Convert to markdown with image files (not base64) // 이미지를 파일로 저장하고 파일 경로를 사용 / Save images as files and use file paths let images_dir = snapshots_dir.join("images").join(file_name); std::fs::create_dir_all(&images_dir).unwrap_or(()); let options = hwp_core::viewer::markdown::MarkdownOptions { image_output_dir: images_dir.to_str().map(\|s\| s.to_string()), use_html: Some(true), include_version: Some(true), include_page_info: Some(true), }; let markdown = document.to_markdown(&options); // 스냅샷 생성 / Create snapshot assert_snapshot_with_path!(snapshot_name_md.as_str(), markdown); // 실제 Markdown 파일로도 저장 / Also save as actual Markdown file let md_file = snapshots_dir.join(format!("{}.md", file_name)); std::fs::create_dir_all(&snapshots_dir).unwrap_or(()); std::fs::write(&md_file, &markdown).unwrap_or_else(\|e\| { eprintln!("Failed to write Markdown file {}: {}", md_file.display(), e); }); } Err(e) => { eprintln!("Skipping {} due to parse error: {}", file_name, e); } } } Err(e) => { eprintln!("Failed to read {}: {}", file_name, e); } } } } #[test] fn test_document_html_snapshot() { let file_path = match find_fixture_file("linespacing.hwp") { Some(path) => path, None => return, // Skip test if file not available }; // 파일명에서 스냅샷 이름 추출 / Extract snapshot name from filename let file_name = std::path::Path::new(&file_path) .file_stem() .and_then(\|n\| n.to_str()) .unwrap_or("unknown"); let snapshot_name = file_name.replace(['-', '.'], "_"); let snapshot_name_html = format!("{}_html", snapshot_name); if let Ok(data) = std::fs::read(&file_path) { let parser = HwpParser::new(); let result = parser.parse(&data); if let Err(e) = &result { eprintln!("Parse error: {:?}", e); } assert!(result.is_ok(), "Should parse HWP document"); let document = result.unwrap(); // Convert to HTML with image files (not base64) // 이미지를 파일로 저장하고 파일 경로를 사용 / Save images as files and use file paths let manifest_dir = env!("CARGO_MANIFEST_DIR"); let snapshots_dir = std::path::Path::new(manifest_dir) .join("tests") .join("snapshots"); let images_dir = snapshots_dir.join("images").join(file_name); std::fs::create_dir_all(&images_dir).unwrap_or(()); let options = hwp_core::viewer::HtmlOptions { image_output_dir: images_dir.to_str().map(\|s\| s.to_string()), html_output_dir: snapshots_dir.to_str().map(\|s\| s.to_string()), include_version: Some(true), include_page_info: Some(true), css_class_prefix: "ohah-hwpjs-".to_string(), }; let html = document.to_html(&options); assert_snapshot_with_path!(snapshot_name_html.as_str(), html); // 실제 HTML 파일로도 저장 / Also save as actual HTML file let html_file = snapshots_dir.join(format!("{}.html", file_name)); std::fs::write(&html_file, &html).unwrap_or_else(\|e\| { eprintln!("Failed to write HTML file: {}", e); }); } } #[test] fn test_headerfooter_html() { // headerfooter.hwp 파일에 대해 HTML 스냅샷 생성 / Generate HTML snapshot for headerfooter.hwp let file_path = match find_headerfooter_file() { Some(path) => path, None => { eprintln!("headerfooter.hwp not found, skipping test"); return; } }; let parser = HwpParser::new(); let manifest_dir = env!("CARGO_MANIFEST_DIR"); let snapshots_dir = std::path::Path::new(manifest_dir) .join("tests") .join("snapshots"); let file_name = std::path::Path::new(&file_path) .file_stem() .and_then(\|n\| n.to_str()) .unwrap_or("unknown"); let snapshot_name = file_name.replace(['-', '.'], "_"); let snapshot_name_html = format!("{}_html", snapshot_name); match std::fs::read(&file_path) { Ok(data) => { match parser.parse(&data) { Ok(document) => { // Convert to HTML with image files (not base64) // 이미지를 파일로 저장하고 파일 경로를 사용 / Save images as files and use file paths let images_dir = snapshots_dir.join("images").join(file_name); std::fs::create_dir_all(&images_dir).unwrap_or(()); let options = hwp_core::viewer::html::HtmlOptions { image_output_dir: images_dir.to_str().map(\|s\| s.to_string()), html_output_dir: snapshots_dir.to_str().map(\|s\| s.to_string()), include_version: Some(true), include_page_info: Some(true), css_class_prefix: "ohah-hwpjs-".to_string(), }; let html = document.to_html(&options); // 스냅샷 생성 / Create snapshot assert_snapshot_with_path!(snapshot_name_html.as_str(), html); // 실제 HTML 파일로도 저장 / Also save as actual HTML file let html_file = snapshots_dir.join(format!("{}.html", file_name)); std::fs::create_dir_all(&snapshots_dir).unwrap_or(()); std::fs::write(&html_file, &html).unwrap_or_else(\|e\| { eprintln!("Failed to write HTML file {}: {}", html_file.display(), e); }); } Err(e) => { eprintln!("Failed to parse {}: {:?}", file_path, e); } } } Err(e) => { eprintln!("Failed to read {}: {}", file_path, e); } } } #[test] fn test_all_fixtures_html_snapshots() { // 모든 fixtures 파일에 대해 HTML 스냅샷 생성 / Generate HTML snapshots for all fixtures files let hwp_files = find_all_hwp_files(); if hwp_files.is_empty() { println!("No HWP files found in fixtures directory"); return; } let parser = HwpParser::new(); let manifest_dir = env!("CARGO_MANIFEST_DIR"); let snapshots_dir = std::path::Path::new(manifest_dir) .join("tests") .join("snapshots"); for file_path in &hwp_files { let file_name = std::path::Path::new(file_path) .file_stem() .and_then(\|n\| n.to_str()) .unwrap_or("unknown"); // 파일명을 스냅샷 이름으로 사용 (특수 문자 제거) / Use filename as snapshot name (remove special chars) let snapshot_name = file_name.replace(['-', '.'], "_"); let snapshot_name_html = format!("{}_html", snapshot_name); match std::fs::read(file_path) { Ok(data) => { match parser.parse(&data) { Ok(document) => { // Convert to HTML with image files (not base64) // 이미지를 파일로 저장하고 파일 경로를 사용 / Save images as files and use file paths let images_dir = snapshots_dir.join("images").join(file_name); std::fs::create_dir_all(&images_dir).unwrap_or(()); let options = hwp_core::viewer::html::HtmlOptions { image_output_dir: images_dir.to_str().map(\|s\| s.to_string()), html_output_dir: snapshots_dir.to_str().map(\|s\| s.to_string()), include_version: Some(true), include_page_info: Some(true), css_class_prefix: String::new(), // table.html과 일치하도록 빈 문자열 사용 }; if file_name == "table" { eprintln!("DEBUG: Processing table.hwp file"); } let html = document.to_html(&options); // 스냅샷 생성 / Create snapshot assert_snapshot_with_path!(snapshot_name_html.as_str(), html); // 실제 HTML 파일로도 저장 / Also save as actual HTML file let html_file = snapshots_dir.join(format!("{}.html", file_name)); std::fs::create_dir_all(&snapshots_dir).unwrap_or(()); std::fs::write(&html_file, &html).unwrap_or_else(\|e\| { eprintln!("Failed to write HTML file {}: {}", html_file.display(), e); }); } Err(e) => { eprintln!("Skipping {} due to parse error: {}", file_name, e); } } } Err(e) => { eprintln!("Failed to read {}: {}", file_name, e); } } } } #[test] fn test_table2_html_snapshot() { // table2.hwp 파일만 테스트 / Test only table2.hwp file let manifest_dir = env!("CARGO_MANIFEST_DIR"); let fixtures_dir = std::path::Path::new(manifest_dir) .join("tests") .join("fixtures"); let file_path = fixtures_dir.join("table2.hwp"); if !file_path.exists() { eprintln!("table2.hwp not found, skipping test"); return; } let parser = HwpParser::new(); let snapshots_dir = std::path::Path::new(manifest_dir) .join("tests") .join("snapshots"); let file_name = "table2"; let snapshot_name_html = "table2_html"; match std::fs::read(&file_path) { Ok(data) => { match parser.parse(&data) { Ok(document) => { // Convert to HTML with image files (not base64) // 이미지를 파일로 저장하고 파일 경로를 사용 / Save images as files and use file paths let images_dir = snapshots_dir.join("images").join(file_name); std::fs::create_dir_all(&images_dir).unwrap_or(()); let options = hwp_core::viewer::html::HtmlOptions { image_output_dir: images_dir.to_str().map(\|s\| s.to_string()), html_output_dir: snapshots_dir.to_str().map(\|s\| s.to_string()), include_version: Some(true), include_page_info: Some(true), css_class_prefix: String::new(), // table.html과 일치하도록 빈 문자열 사용 }; eprintln!("DEBUG: Processing table2.hwp file"); let html = document.to_html(&options); // 스냅샷 생성 / Create snapshot assert_snapshot_with_path!(snapshot_name_html, html); // 실제 HTML 파일로도 저장 / Also save as actual HTML file let html_file = snapshots_dir.join(format!("{}.html", file_name)); std::fs::create_dir_all(&snapshots_dir).unwrap_or(()); std::fs::write(&html_file, &html).unwrap_or_else(\|e\| { eprintln!("Failed to write HTML file {}: {}", html_file.display(), e); }); } Err(e) => { eprintln!("Parse error for table2.hwp: {}", e); panic!("Failed to parse table2.hwp: {}", e); } } } Err(e) => { eprintln!("Failed to read table2.hwp: {}", e); panic!("Failed to read table2.hwp: {}", e); } } } #[test] fn test_parse_all_fixtures() { // 모든 fixtures 파일을 파싱하여 에러가 없는지 확인 / Parse all fixtures files to check for errors let hwp_files = find_all_hwp_files(); if hwp_files.is_empty() { println!("No HWP files found in fixtures directory"); return; } let parser = HwpParser::new(); let mut success_count = 0; let mut error_count = 0; let mut error_files: Vec<(String, String, String)> = Vec::new(); // (file, version, error) for file_path in &hwp_files { match std::fs::read(file_path) { Ok(data) => { // FileHeader 버전 확인 / Check FileHeader version use hwp_core::CfbParser; use hwp_core::FileHeader; let version_str = match CfbParser::parse(&data) { Ok(mut cfb) => match CfbParser::read_stream(&mut cfb, "FileHeader") { Ok(fileheader_data) => match FileHeader::parse(&fileheader_data) { Ok(fh) => { let major = (fh.version >> 24) & 0xFF; let minor = (fh.version >> 16) & 0xFF; let patch = (fh.version >> 8) & 0xFF; let revision = fh.version & 0xFF; format!("{}.{}.{}.{}", major, minor, patch, revision) } Err(_) => "unknown".to_string(), }, Err(_) => "unknown".to_string(), }, Err(_) => "unknown".to_string(), }; match parser.parse(&data) { Ok(_document) => { success_count += 1; } Err(e) => { error_count += 1; let file_name = std::path::Path::new(file_path) .file_name() .and_then(\|n\| n.to_str()) .unwrap_or(file_path); error_files.push((file_name.to_string(), version_str, e.to_string())); eprintln!("Failed to parse {}: {}", file_path, e); } } } Err(e) => { error_count += 1; eprintln!("Failed to read {}: {}", file_path, e); } } } println!("\n=== Summary ===",); println!( "Parsed {} files successfully, {} errors", success_count, error_count ); // 에러 유형별 통계 / Statistics by error type let mut object_common_errors: Vec<(String, String, String)> = Vec::new(); let mut other_errors: Vec<(String, String, String)> = Vec::new(); for (file, version, error) in &error_files { if error.contains("Object common properties must be at least 42 bytes") { object_common_errors.push((file.clone(), version.clone(), error.clone())); } else { other_errors.push((file.clone(), version.clone(), error.clone())); } } if !object_common_errors.is_empty() { println!( "\n=== Object common properties 40-byte errors ({} files) ===", object_common_errors.len() ); for (file, version, error) in &object_common_errors { println!(" {} (version: {}): {}", file, version, error); } } if !other_errors.is_empty() { println!("\n=== Other errors ({} files) ===", other_errors.len()); for (file, version, error) in &other_errors { println!(" {} (version: {}): {}", file, version, error); } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	true
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/packages/hwpjs/build.rs	packages/hwpjs/build.rs	fn main() { napi_build::setup(); }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/packages/hwpjs/src/lib.rs	packages/hwpjs/src/lib.rs	#![deny(clippy::all)] use base64::{engine::general_purpose::STANDARD, Engine as _}; use hwp_core::HwpParser; use napi::bindgen_prelude::Buffer; use napi_derive::napi; /// Convert HWP file to JSON /// /// # Arguments /// * `data` - Byte array containing HWP file data (Buffer or Uint8Array) /// /// # Returns /// Parsed HWP document as JSON string #[napi] pub fn to_json(data: Buffer) -> Result<String, napi::Error> { let parser = HwpParser::new(); let data_vec: Vec<u8> = data.into(); let document = parser.parse(&data_vec).map_err(napi::Error::from_reason)?; // Convert to JSON serde_json::to_string(&document) .map_err(\|e\| napi::Error::from_reason(format!("Failed to serialize to JSON: {}", e))) } /// Image format option for markdown conversion /// 마크다운 변환 시 이미지 형식 옵션 #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum ImageFormat { /// Base64 data URI embedded directly in markdown /// 마크다운에 base64 데이터 URI를 직접 포함 Base64, /// Image data as separate blob array /// 이미지를 별도 blob 배열로 반환 Blob, } /// Markdown conversion options #[napi(object)] pub struct ToMarkdownOptions { /// Optional directory path to save images as files. If None, images are embedded as base64 data URIs. /// 이미지를 파일로 저장할 디렉토리 경로 (선택). None이면 base64 데이터 URI로 임베드됩니다. pub image_output_dir: Option<String>, /// Image format: 'base64' to embed base64 data URI directly in markdown, 'blob' to return as separate ImageData array (default: 'blob') /// 이미지 형식: 'base64'는 마크다운에 base64 데이터 URI를 직접 포함, 'blob'은 별도 ImageData 배열로 반환 (기본값: 'blob') pub image: Option<String>, /// Whether to use HTML tags (if Some(true), use <br> tags in areas where line breaks are not possible, such as tables) /// HTML 태그 사용 여부 (Some(true)인 경우 테이블 등 개행 불가 영역에 <br> 태그 사용) pub use_html: Option<bool>, /// Whether to include version information /// 버전 정보 포함 여부 pub include_version: Option<bool>, /// Whether to include page information /// 페이지 정보 포함 여부 pub include_page_info: Option<bool>, } /// Image data structure #[napi(object)] pub struct ImageData { /// Image ID (e.g., "image-0") /// 이미지 ID (예: "image-0") pub id: String, /// Image data as Uint8Array /// 이미지 데이터 (Uint8Array) pub data: Buffer, /// Image format (e.g., "jpg", "png", "bmp") /// 이미지 형식 (예: "jpg", "png", "bmp") pub format: String, } /// Markdown conversion result #[napi(object)] pub struct ToMarkdownResult { /// Markdown string with image references (e.g., "![이미지](image-0)") /// 이미지 참조가 포함된 마크다운 문자열 (예: "![이미지](image-0)") pub markdown: String, /// Extracted image data /// 추출된 이미지 데이터 pub images: Vec<ImageData>, } /// Convert HWP file to Markdown format /// /// # Arguments /// * `data` - Byte array containing HWP file data (Buffer or Uint8Array) /// * `options` - Optional markdown conversion options /// /// # Returns /// ToMarkdownResult containing markdown string and image data #[napi] pub fn to_markdown( data: Buffer, options: Option<ToMarkdownOptions>, ) -> Result<ToMarkdownResult, napi::Error> { let parser = HwpParser::new(); let data_vec: Vec<u8> = data.into(); let document = parser.parse(&data_vec).map_err(napi::Error::from_reason)?; // Determine image format option (default: 'blob') let image_format = options .as_ref() .and_then(\|o\| o.image.as_ref()) .map(\|s\| s.to_lowercase()) .map(\|s\| match s.as_str() { "base64" => ImageFormat::Base64, "blob" => ImageFormat::Blob, _ => ImageFormat::Blob, // Default to blob for invalid values }) .unwrap_or(ImageFormat::Blob); // Build markdown options let markdown_options = hwp_core::viewer::markdown::MarkdownOptions { image_output_dir: None, // Force base64 mode for internal processing use_html: options.as_ref().and_then(\|o\| o.use_html), include_version: options.as_ref().and_then(\|o\| o.include_version), include_page_info: options.as_ref().and_then(\|o\| o.include_page_info), }; // Convert to markdown with base64 images let mut markdown = document.to_markdown(&markdown_options); // Extract images from BinData let mut images = Vec::new(); match image_format { ImageFormat::Base64 => { // For base64 format, we need to ensure all image placeholders are replaced with base64 URIs // to_markdown should already generate base64 URIs, but we'll make sure by replacing any placeholders for (index, bin_item) in document.bin_data.items.iter().enumerate() { let mime_type = get_mime_type_from_bindata_id(&document, bin_item.index); let base64_data_uri = format!("data:{};base64,{}", mime_type, bin_item.data); let image_id = format!("image-{}", index); // Replace any placeholder with base64 URI let placeholder_pattern = format!("![이미지]({})", image_id); if markdown.contains(&placeholder_pattern) { markdown = markdown.replace( &placeholder_pattern, &format!("![이미지]({})", base64_data_uri), ); } // Also check if there's already a base64 URI and ensure it's correct // (This handles the case where to_markdown already generated base64) // No need to do anything if base64 is already there } // Don't add to images array for base64 format } ImageFormat::Blob => { // Extract all images and replace base64 URIs with placeholders for (index, bin_item) in document.bin_data.items.iter().enumerate() { // Get extension and mime type from bin_data_records let extension = get_extension_from_bindata_id(&document, bin_item.index); let mime_type = get_mime_type_from_bindata_id(&document, bin_item.index); let base64_data_uri = format!("data:{};base64,{}", mime_type, bin_item.data); let image_id = format!("image-{}", index); // Decode base64 data for blob format let image_data = STANDARD.decode(&bin_item.data).map_err(\|e\| { napi::Error::from_reason(format!("Failed to decode base64 image data: {}", e)) })?; images.push(ImageData { id: image_id.clone(), data: Buffer::from(image_data), format: extension, }); // Replace base64 data URIs in markdown with placeholders // Pattern: ![이미지](data:image/...;base64,...) let pattern = format!("![이미지]({})", base64_data_uri); let replacement = format!("![이미지]({})", image_id); markdown = markdown.replace(&pattern, &replacement); // Also handle cases where the pattern might be split across lines or have different formatting let pattern2 = format!( "![이미지]({})", base64_data_uri.replace("(", "\\(").replace(")", "\\)") ); markdown = markdown.replace(&pattern2, &replacement); } } } Ok(ToMarkdownResult { markdown, images }) } /// Get file extension from BinData ID fn get_extension_from_bindata_id( document: &hwp_core::HwpDocument, bindata_id: hwp_core::WORD, ) -> String { for record in &document.doc_info.bin_data { if let hwp_core::BinDataRecord::Embedding { embedding, .. } = record { if embedding.binary_data_id == bindata_id { return embedding.extension.clone(); } } } "jpg".to_string() } /// Get MIME type from BinData ID fn get_mime_type_from_bindata_id( document: &hwp_core::HwpDocument, bindata_id: hwp_core::WORD, ) -> String { for record in &document.doc_info.bin_data { if let hwp_core::BinDataRecord::Embedding { embedding, .. } = record { if embedding.binary_data_id == bindata_id { return match embedding.extension.to_lowercase().as_str() { "jpg" \| "jpeg" => "image/jpeg", "png" => "image/png", "gif" => "image/gif", "bmp" => "image/bmp", _ => "image/jpeg", } .to_string(); } } } "image/jpeg".to_string() } /// HTML conversion options #[napi(object)] pub struct ToHtmlOptions { /// Optional directory path to save images as files. If None, images are embedded as base64 data URIs. /// 이미지를 파일로 저장할 디렉토리 경로 (선택). None이면 base64 데이터 URI로 임베드됩니다. pub image_output_dir: Option<String>, /// Directory path where HTML file is saved (used for calculating relative image paths) /// HTML 파일이 저장되는 디렉토리 경로 (이미지 상대 경로 계산에 사용) pub html_output_dir: Option<String>, /// Whether to include version information /// 버전 정보 포함 여부 pub include_version: Option<bool>, /// Whether to include page information /// 페이지 정보 포함 여부 pub include_page_info: Option<bool>, /// CSS class prefix (default: "" - noori.html style) /// CSS 클래스 접두사 (기본값: "" - noori.html 스타일) pub css_class_prefix: Option<String>, } /// Convert HWP file to HTML format /// /// # Arguments /// * `data` - Byte array containing HWP file data (Buffer or Uint8Array) /// * `options` - Optional HTML conversion options /// /// # Returns /// HTML string representation of the document #[napi] pub fn to_html(data: Buffer, options: Option<ToHtmlOptions>) -> Result<String, napi::Error> { let parser = HwpParser::new(); let data_vec: Vec<u8> = data.into(); let document = parser.parse(&data_vec).map_err(napi::Error::from_reason)?; // Build HTML options let html_options = hwp_core::viewer::html::HtmlOptions { image_output_dir: options.as_ref().and_then(\|o\| o.image_output_dir.clone()), html_output_dir: options.as_ref().and_then(\|o\| o.html_output_dir.clone()), include_version: options.as_ref().and_then(\|o\| o.include_version), include_page_info: options.as_ref().and_then(\|o\| o.include_page_info), css_class_prefix: options .as_ref() .and_then(\|o\| o.css_class_prefix.clone()) .unwrap_or_default(), }; // Convert to HTML let html = document.to_html(&html_options); Ok(html) } /// Extract FileHeader from HWP file as JSON /// /// # Arguments /// * `data` - Byte array containing HWP file data (Buffer or Uint8Array) /// /// # Returns /// FileHeader as JSON string #[napi] pub fn file_header(data: Buffer) -> Result<String, napi::Error> { let parser = HwpParser::new(); let data_vec: Vec<u8> = data.into(); parser .parse_fileheader_json(&data_vec) .map_err(napi::Error::from_reason) }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/packages/hwpjs/crates/lib/build.rs	packages/hwpjs/crates/lib/build.rs	fn main() { craby_build::setup(); }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/packages/hwpjs/crates/lib/src/lib.rs	packages/hwpjs/crates/lib/src/lib.rs	#[rustfmt::skip] pub(crate) mod ffi; pub(crate) mod generated; pub(crate) mod hwpjs_impl;	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/packages/hwpjs/crates/lib/src/hwpjs_impl.rs	packages/hwpjs/crates/lib/src/hwpjs_impl.rs	use craby::{prelude::, throw}; use crate::ffi::bridging::; use crate::generated::*; use hwp_core::HwpParser; pub struct Hwpjs { ctx: Context, } #[craby_module] impl HwpjsSpec for Hwpjs { fn new(ctx: Context) -> Self { Self { ctx } } fn id(&self) -> usize { self.ctx.id } fn to_json(&mut self, data: Vec<u8>) -> String { let parser = HwpParser::new(); let document = parser.parse(&data).unwrap_or_else(\|e\| throw!("{}", e)); serde_json::to_string(&document) .unwrap_or_else(\|e\| throw!("Failed to serialize to JSON: {}", e)) } fn to_markdown(&mut self, data: Vec<u8>, options: ToMarkdownOptions) -> ToMarkdownResult { let parser = HwpParser::new(); let document = parser.parse(&data).unwrap_or_else(\|e\| throw!("{}", e)); // ToMarkdownOptions를 hwp_core::viewer::markdown::MarkdownOptions로 변환 let image_output_dir: Nullable<String> = options.image_output_dir.into(); let use_html = Some(options.use_html); let include_version = Some(options.include_version); let include_page_info = Some(options.include_page_info); let markdown_options = hwp_core::viewer::markdown::MarkdownOptions { image_output_dir: image_output_dir.into_value(), use_html, include_version, include_page_info, }; // 마크다운 변환 (이미지는 base64로 임베드) let markdown = document.to_markdown(&markdown_options); ToMarkdownResult { markdown } } fn file_header(&mut self, data: Vec<u8>) -> String { let parser = HwpParser::new(); parser .parse_fileheader_json(&data) .unwrap_or_else(\|e\| throw!("{}", e)) } }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false
ohah/hwpjs	https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/packages/hwpjs/crates/lib/src/ffi.rs	packages/hwpjs/crates/lib/src/ffi.rs	// Auto generated by Craby. DO NOT EDIT. #[rustfmt::skip] use craby::prelude::; use crate::generated::; use crate::hwpjs_impl::; use bridging::; #[cxx::bridge(namespace = "craby::hwpjs::bridging")] pub mod bridging { #[derive(Clone)] struct NullableString { null: bool, val: String, } #[derive(Clone)] struct ToMarkdownResult { markdown: String, } #[derive(Clone)] struct ToMarkdownOptions { image_output_dir: NullableString, image: NullableString, use_html: bool, include_version: bool, include_page_info: bool, } extern "Rust" { type Hwpjs; #[cxx_name = "createHwpjs"] fn create_hwpjs(id: usize, data_path: &str) -> Box<Hwpjs>; #[cxx_name = "createVecFromSlice"] fn create_vec_from_slice(data: &[u8]) -> Vec<u8>; #[cxx_name = "fileHeader"] fn hwpjs_file_header(it_: &mut Hwpjs, data: Vec<u8>) -> Result<String>; #[cxx_name = "toJson"] fn hwpjs_to_json(it_: &mut Hwpjs, data: Vec<u8>) -> Result<String>; #[cxx_name = "toMarkdown"] fn hwpjs_to_markdown( it_: &mut Hwpjs, data: Vec<u8>, options: ToMarkdownOptions, ) -> Result<ToMarkdownResult>; } } fn create_hwpjs(id: usize, data_path: &str) -> Box<Hwpjs> { let ctx = Context::new(id, data_path); Box::new(Hwpjs::new(ctx)) } fn create_vec_from_slice(data: &[u8]) -> Vec<u8> { data.to_vec() } fn hwpjs_file_header(it_: &mut Hwpjs, data: Vec<u8>) -> Result<String, anyhow::Error> { craby::catch_panic!({ let ret = it_.file_header(data); ret }) } fn hwpjs_to_json(it_: &mut Hwpjs, data: Vec<u8>) -> Result<String, anyhow::Error> { craby::catch_panic!({ let ret = it_.to_json(data); ret }) } fn hwpjs_to_markdown( it_: &mut Hwpjs, data: Vec<u8>, options: ToMarkdownOptions, ) -> Result<ToMarkdownResult, anyhow::Error> { craby::catch_panic!({ let ret = it_.to_markdown(data, options); ret }) }	rust	MIT	19df26a209c6e780b4c3b03d2ab628209e1ae311	2026-01-04T20:24:59.575438Z	false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/viewer/markdown/document/bodytext/list_header.rs

crates/hwp-core/src/viewer/markdown/document/bodytext/list_header.rs

//! ListHeader conversion to Markdown //! ListHeader를 마크다운으로 변환하는 모듈 //! //! 스펙 문서 매핑: 표 57 - 본문의 데이터 레코드, LIST_HEADER (HWPTAG_BEGIN + 56) //! Spec mapping: Table 57 - BodyText data records, LIST_HEADER (HWPTAG_BEGIN + 56) //! //! Note: 실제 변환은 convert_paragraph_to_markdown에서 처리되므로 //! 이 모듈은 향후 확장을 위해 준비되었습니다. //! Note: Actual conversion is handled in convert_paragraph_to_markdown, //! so this module is prepared for future expansion. //! //! This module is currently empty but reserved for future ListHeader-specific conversion logic. //! 이 모듈은 현재 비어있지만 향후 ListHeader 전용 변환 로직을 위해 예약되어 있습니다.

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/viewer/markdown/document/bodytext/paragraph.rs

crates/hwp-core/src/viewer/markdown/document/bodytext/paragraph.rs

/// Paragraph conversion to Markdown /// 문단을 마크다운으로 변환하는 모듈 /// /// 스펙 문서 매핑: 표 57 - 본문의 데이터 레코드 /// Spec mapping: Table 57 - BodyText data records use crate::document::bodytext::CharShapeInfo; use crate::document::CharShape; use crate::document::{HwpDocument, Paragraph, ParagraphRecord}; use crate::viewer::markdown::collect::collect_text_and_images_from_paragraph; use crate::viewer::markdown::document::bodytext::para_text::{ convert_para_text_to_markdown, convert_para_text_to_markdown_with_char_shapes, }; use crate::viewer::markdown::document::bodytext::shape_component::convert_shape_component_children_to_markdown; use crate::viewer::markdown::document::bodytext::shape_component_picture::convert_shape_component_picture_to_markdown; use crate::viewer::markdown::document::bodytext::table::convert_table_to_markdown; use crate::viewer::markdown::utils::{ convert_to_outline_with_number, is_text_part, OutlineNumberTracker, }; use crate::viewer::markdown::MarkdownOptions; /// Convert a paragraph to markdown /// 문단을 마크다운으로 변환 pub fn convert_paragraph_to_markdown( paragraph: &Paragraph, document: &HwpDocument, options: &MarkdownOptions, tracker: &mut OutlineNumberTracker, ) -> String { if paragraph.records.is_empty() { return String::new(); } let mut parts = Vec::new(); let mut text_parts = Vec::new(); // 같은 문단 내의 텍스트 레코드들을 모음 / Collect text records in the same paragraph let mut char_shapes: Vec<CharShapeInfo> = Vec::new(); // 문단의 글자 모양 정보 수집 / Collect character shape information for paragraph // 먼저 ParaCharShape 레코드를 수집 / First collect ParaCharShape records for record in &paragraph.records { if let ParagraphRecord::ParaCharShape { shapes } = record { char_shapes.extend(shapes.clone()); } } // CharShape를 가져오는 클로저 / Closure to get CharShape let get_char_shape = |shape_id: u32| -> Option<&CharShape> { document.doc_info.char_shapes.get(shape_id as usize) }; // Process all records in order / 모든 레코드를 순서대로 처리 for record in &paragraph.records { match record { ParagraphRecord::ParaText { text, control_char_positions, inline_control_params: _, .. } => { // ParaText 변환 / Convert ParaText // 표 셀 내부의 텍스트는 이미 Table.cells에 포함되어 convert_table_to_markdown에서 처리되므로 // 여기서는 표 앞뒤의 일반 텍스트도 정상적으로 처리됨 // Text inside table cells is already included in Table.cells and processed in convert_table_to_markdown, // so regular text before/after tables is also processed normally here let text_md = if !char_shapes.is_empty() { convert_para_text_to_markdown_with_char_shapes( text, control_char_positions, &char_shapes, Some(&get_char_shape), ) } else { convert_para_text_to_markdown(text, control_char_positions) }; if let Some(text_md) = text_md { // 같은 문단 내의 텍스트는 나중에 합침 / Text in the same paragraph will be combined later text_parts.push(text_md); } } ParagraphRecord::ShapeComponent { shape_component: _, children, } => { // SHAPE_COMPONENT의 children을 재귀적으로 처리 / Recursively process SHAPE_COMPONENT's children let shape_parts = convert_shape_component_children_to_markdown( children, document, options.image_output_dir.as_deref(), tracker, ); parts.extend(shape_parts); } ParagraphRecord::ShapeComponentPicture { shape_component_picture, } => { // ShapeComponentPicture 변환 / Convert ShapeComponentPicture if let Some(image_md) = convert_shape_component_picture_to_markdown( shape_component_picture, document, options.image_output_dir.as_deref(), ) { parts.push(image_md); } } ParagraphRecord::CtrlHeader { header, children, paragraphs: ctrl_paragraphs, .. } => { // 마크다운으로 표현할 수 없는 컨트롤 헤더는 건너뜀 / Skip control headers that cannot be expressed in markdown use crate::viewer::markdown::utils::should_process_control_header; if !should_process_control_header(header) { // CTRL_HEADER 내부의 직접 문단 처리 / Process direct paragraphs inside CTRL_HEADER for para in ctrl_paragraphs { let para_md = convert_paragraph_to_markdown(para, document, options, tracker); if !para_md.is_empty() { parts.push(para_md); } } // CTRL_HEADER의 children 처리 (예: SHAPE_COMPONENT_PICTURE) / Process CTRL_HEADER's children (e.g., SHAPE_COMPONENT_PICTURE) for child in children { match child { ParagraphRecord::ShapeComponentPicture { shape_component_picture, } => { if let Some(image_md) = convert_shape_component_picture_to_markdown( shape_component_picture, document, options.image_output_dir.as_deref(), ) { parts.push(image_md); } } _ => { // 기타 자식 레코드는 무시 (이미 처리된 경우만 도달) / Ignore other child records (only reached if already processed) } } } continue; // 이 컨트롤 헤더는 더 이상 처리하지 않음 / Don't process this control header further } // 컨트롤 헤더의 자식 레코드 처리 (레벨 2, 예: 테이블, 그림 등) / Process control header children (level 2, e.g., table, images, etc.) let mut has_table = false; // 표 셀 내부의 텍스트와 이미지를 수집하여 셀 내부 문단인지 확인 // Collect text and images from paragraphs in Table.cells to check if they are cell content // 포인터 비교는 복사된 객체에서 실패할 수 있으므로 텍스트 내용과 이미지 ID로 비교 // Pointer comparison may fail with copied objects, so compare by text content and image ID let mut table_cell_texts: std::collections::HashSet<String> = std::collections::HashSet::new(); let mut table_cell_image_ids: std::collections::HashSet<u16> = std::collections::HashSet::new(); let mut table_cell_para_ids: std::collections::HashSet<u32> = std::collections::HashSet::new(); // 표 셀 내부 문단의 instance_id 수집 let mut table_opt: Option<&crate::document::bodytext::Table> = None; let mut table_index: Option<usize> = None; let is_table_control = header.ctrl_id == crate::document::CtrlId::TABLE; // 먼저 TABLE을 찾아서 table_opt에 저장 / First find TABLE and store in table_opt let children_slice: &[ParagraphRecord] = children; for (idx, child) in children_slice.iter().enumerate() { if let ParagraphRecord::Table { table } = child { table_opt = Some(table); table_index = Some(idx); break; } } if let Some(table) = table_opt { for cell in &table.cells { for para in &cell.paragraphs { // 문단의 instance_id 수집 (0이 아닌 경우만) / Collect paragraph instance_id (only if not 0) if para.para_header.instance_id != 0 { table_cell_para_ids.insert(para.para_header.instance_id); } // ParaText의 텍스트를 수집 / Collect text from ParaText // 재귀적으로 모든 레코드를 확인하여 이미지 ID 수집 / Recursively check all records to collect image IDs collect_text_and_images_from_paragraph( para, &mut table_cell_texts, &mut table_cell_image_ids, ); } } } // libhwp 방식: 파서 단계에서 TABLE 이전/이후의 LIST_HEADER를 children에 추가하지 않으므로 // 여기서는 처리하지 않음 // libhwp approach: LIST_HEADERs (before/after TABLE) are not added to children in parser stage, // so we don't process them here // TABLE 이전의 LIST_HEADER는 캡션으로 별도 처리되고, // TABLE 이후의 LIST_HEADER는 셀로만 처리됨 // LIST_HEADERs before TABLE are processed as captions separately, // and LIST_HEADERs after TABLE are only processed as cells // 컨트롤 헤더의 자식 레코드들을 순회하며 처리 / Iterate through control header's child records and process them let mut index = 0; let children_slice: &[ParagraphRecord] = children; let is_shape_object = header.ctrl_id == crate::document::CtrlId::SHAPE_OBJECT; while index < children_slice.len() { let child = &children_slice[index]; match child { ParagraphRecord::Table { table } => { // 표 변환 / Convert table let table_md = convert_table_to_markdown(table, document, options, tracker); if !table_md.is_empty() { parts.push(table_md); has_table = true; } index += 1; } ParagraphRecord::ListHeader { paragraphs, .. } => { // LIST_HEADER 처리 (표 아래 캡션 등) / Process LIST_HEADER (caption below, etc.) // libhwp 방식: TABLE 이후의 LIST_HEADER는 Table.cells에 포함되어 있으므로 children에서 처리하지 않음 // libhwp approach: LIST_HEADERs after TABLE are included in Table.cells, so don't process in children if let Some(table_idx) = table_index { if index > table_idx && is_table_control { // TABLE 이후의 LIST_HEADER는 이미 Table.cells에 포함되어 있으므로 건너뜀 // LIST_HEADERs after TABLE are already included in Table.cells, so skip // libhwp는 TABLE 이후의 LIST_HEADER를 children에서 처리하지 않고, // TABLE을 읽은 후 명시적으로 각 셀을 순회하며 처리함 // libhwp doesn't process LIST_HEADERs after TABLE in children, // but processes them explicitly when iterating through cells after reading TABLE } else { // 표 앞의 LIST_HEADER는 이미 처리됨 / LIST_HEADER before table is already processed // 표가 없거나 표 셀 내부가 아닌 경우 일반 처리 / General processing if no table or not inside table cell for para in paragraphs { let para_md = convert_paragraph_to_markdown( para, document, options, tracker, ); if !para_md.is_empty() { parts.push(para_md); } } } } else { // 표가 없는 경우 일반 처리 / General processing if no table for para in paragraphs { let para_md = convert_paragraph_to_markdown( para, document, options, tracker, ); if !para_md.is_empty() { parts.push(para_md); } } } index += 1; } ParagraphRecord::ShapeComponent { shape_component: _, children: shape_children, } => { // SHAPE_COMPONENT의 children 처리 (SHAPE_COMPONENT_PICTURE 등) / Process SHAPE_COMPONENT's children (SHAPE_COMPONENT_PICTURE, etc.) // 먼저 표 셀 내부의 이미지인지 확인 / First check if images are inside table cells let mut shape_parts_to_output = Vec::new(); let mut has_image_in_shape = false; for child in shape_children { match child { ParagraphRecord::ShapeComponentPicture { shape_component_picture, } => { // 표 셀 내부의 이미지인지 확인 (bindata_id로 직접 비교) / Check if image is inside table cell (direct comparison by bindata_id) let is_table_cell_image = table_cell_image_ids.contains( &shape_component_picture.picture_info.bindata_id, ); if is_table_cell_image { // 표 셀 내부의 이미지는 표 셀에 이미 포함되므로 여기서는 표시하지 않음 // Images inside table cells are already included in table cells, so don't display here has_image_in_shape = true; } else { // 표 셀 내부가 아닌 경우 이미지 변환 / Convert image if not inside table cell if let Some(image_md) = convert_shape_component_picture_to_markdown( shape_component_picture, document, options.image_output_dir.as_deref(), ) { shape_parts_to_output.push(image_md); has_image_in_shape = true; } } } ParagraphRecord::ListHeader { paragraphs, .. } => { // LIST_HEADER의 paragraphs 처리 (글상자 텍스트) / Process LIST_HEADER's paragraphs (textbox text) for para in paragraphs { let para_md = convert_paragraph_to_markdown( para, document, options, tracker, ); if !para_md.is_empty() { shape_parts_to_output.push(para_md); } } } _ => {} } } // 변환된 부분들을 출력 / Output converted parts for shape_part in shape_parts_to_output { if has_table && has_image_in_shape { // 표가 있고 이미지가 있는 경우, 이미지가 표 셀 내부가 아니므로 출력 // If table exists and image exists, image is not inside table cell, so output parts.push(shape_part); } else if is_shape_object { // SHAPE_OBJECT의 경우 표 밖에서도 이미지를 처리 // For SHAPE_OBJECT, process image even outside table parts.push(shape_part); } else { // 기타 경우에는 출력 // For other cases, output parts.push(shape_part); } } index += 1; } ParagraphRecord::ShapeComponentPicture { shape_component_picture, } => { // ShapeComponentPicture 변환 / Convert ShapeComponentPicture // 표 셀 내부의 이미지인지 확인 / Check if image is inside table cell let is_table_cell_image = table_cell_image_ids .contains(&shape_component_picture.picture_info.bindata_id); // 표 셀 내부의 이미지는 표 셀에 이미 포함되므로 여기서는 표시하지 않음 // Images inside table cells are already included in table cells, so don't display here if !is_table_cell_image { if let Some(image_md) = convert_shape_component_picture_to_markdown( shape_component_picture, document, options.image_output_dir.as_deref(), ) { if has_table { // 표가 있지만 셀 내부가 아닌 경우 (표 위/아래 이미지 등) // Table exists but not inside cell (e.g., image above/below table) parts.push(image_md); } else if is_shape_object { // SHAPE_OBJECT의 경우 표 밖에서도 이미지를 처리 // For SHAPE_OBJECT, process image even outside table parts.push(image_md); } else { // 기타 경우에는 출력 // For other cases, output parts.push(image_md); } } } index += 1; } _ => { // 기타 레코드는 무시 / Ignore other records // CtrlHeader는 이미 위에서 처리됨 / CtrlHeader is already processed above index += 1; } } } // CTRL_HEADER 내부의 직접 문단 처리 / Process direct paragraphs inside CTRL_HEADER for para in ctrl_paragraphs { // 표 셀 내부의 문단인지 확인 / Check if paragraph is inside table cell let is_table_cell = if is_table_control && table_opt.is_some() { // 먼저 instance_id로 확인 (가장 정확, 0이 아닌 경우만) / First check by instance_id (most accurate, only if not 0) let is_table_cell_by_id = !table_cell_para_ids.is_empty() && para.para_header.instance_id != 0 && table_cell_para_ids.contains(&para.para_header.instance_id); // instance_id로 확인되지 않으면 텍스트와 이미지로 확인 / If not found by instance_id, check by text and images if is_table_cell_by_id { true } else { // 재귀적으로 문단에서 텍스트와 이미지를 수집하여 표 셀 내부인지 확인 // Recursively collect text and images from paragraph to check if inside table cell let mut para_texts = std::collections::HashSet::new(); let mut para_image_ids = std::collections::HashSet::new(); collect_text_and_images_from_paragraph( para, &mut para_texts, &mut para_image_ids, ); // 수집한 텍스트나 이미지가 표 셀 내부에 포함되어 있는지 확인 // Check if collected text or images are included in table cells (!para_texts.is_empty() && para_texts .iter() .any(|text| table_cell_texts.contains(text))) || (!para_image_ids.is_empty() && para_image_ids .iter() .any(|id| table_cell_image_ids.contains(id))) } } else { false }; // 표 셀 내부가 아닌 경우에만 처리 / Only process if not inside table cell if !is_table_cell { let para_md = convert_paragraph_to_markdown(para, document, options, tracker); if !para_md.is_empty() { parts.push(para_md); } } } } _ => { // 기타 레코드는 무시 / Ignore other records } } } // 같은 문단 내의 텍스트를 합침 / Combine text in the same paragraph if !text_parts.is_empty() { let combined_text = text_parts.join(""); // 개요 레벨 확인 및 개요 번호 추가 / Check outline level and add outline number let outline_md = convert_to_outline_with_number( &combined_text, &paragraph.para_header, document, tracker, ); parts.push(outline_md); } // 마크다운 문법에 맞게 개행 처리 / Handle line breaks according to markdown syntax // 텍스트가 연속으로 나올 때는 스페이스 2개 + 개행, 블록 요소 사이는 빈 줄 // For consecutive text: two spaces + newline, for block elements: blank line if parts.is_empty() { return String::new(); } if parts.len() == 1 { return parts[0].clone(); } let mut result = String::new(); for (i, part) in parts.iter().enumerate() { if i > 0 { // 이전 part가 텍스트이고 현재 part도 텍스트인 경우: 스페이스 2개 + 개행 // If previous part is text and current part is also text: two spaces + newline if is_text_part(&parts[i - 1]) && is_text_part(part) { result.push_str(" \n"); } // 블록 요소가 포함된 경우: 빈 줄 // When block elements are involved, use blank line else { result.push_str("\n\n"); } } result.push_str(part); } result }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/viewer/markdown/document/bodytext/para_text.rs

crates/hwp-core/src/viewer/markdown/document/bodytext/para_text.rs

/// ParaText conversion to Markdown /// ParaText를 마크다운으로 변환하는 모듈 /// /// 스펙 문서 매핑: 표 57 - 본문의 데이터 레코드, PARA_TEXT (HWPTAG_BEGIN + 51) /// Spec mapping: Table 57 - BodyText data records, PARA_TEXT (HWPTAG_BEGIN + 51) use crate::document::bodytext::{CharShapeInfo, ControlChar, ControlCharPosition}; use crate::document::CharShape; /// 의미 있는 텍스트인지 확인합니다. / Check if text is meaningful. /// /// 공백만 있는 텍스트는 의미 없다고 판단합니다. /// Text containing only whitespace is considered meaningless. /// /// # Arguments / 매개변수 /// * `text` - 제어 문자가 이미 제거된 텍스트 / Text with control characters already removed /// * `control_positions` - 제어 문자 위치 정보 (현재는 사용되지 않음) / Control character positions (currently unused) /// /// # Returns / 반환값 /// 의미 있는 텍스트이면 `true`, 그렇지 않으면 `false` / `true` if meaningful, `false` otherwise /// /// # Note /// 제어 문자는 이미 파싱 단계에서 text에서 제거되었으므로, /// 텍스트가 비어있지 않은지만 확인합니다. /// Control characters are already removed from text during parsing, /// so we only check if text is not empty. pub(crate) fn is_meaningful_text(text: &str, _control_positions: &[ControlCharPosition]) -> bool { !text.trim().is_empty() } /// Convert ParaText to markdown /// ParaText를 마크다운으로 변환 /// /// # Arguments / 매개변수 /// * `text` - 텍스트 내용 / Text content /// * `control_positions` - 제어 문자 위치 정보 / Control character positions /// /// # Returns / 반환값 /// 마크다운 문자열 / Markdown string /// Convert character index to byte index in UTF-8 string /// UTF-8 문자열에서 문자 인덱스를 바이트 인덱스로 변환 fn char_index_to_byte_index(text: &str, char_idx: usize) -> Option<usize> { text.char_indices() .nth(char_idx) .map(|(byte_idx, _)| byte_idx) } /// CharShape 정보를 사용하여 텍스트를 구간별로 나누고 마크다운 스타일을 적용 /// Divide text into segments by CharShape information and apply markdown styles fn convert_text_with_char_shapes<'a>( text: &str, control_positions: &[ControlCharPosition], char_shapes: &[CharShapeInfo], get_char_shape: &'a dyn Fn(u32) -> Option<&'a CharShape>, ) -> Option<String> { if text.trim().is_empty() { return None; } let text_chars: Vec<char> = text.chars().collect(); let text_len = text_chars.len(); // CharShape 정보를 position 기준으로 정렬 / Sort CharShape info by position let mut sorted_shapes: Vec<_> = char_shapes.iter().collect(); sorted_shapes.sort_by_key(|shape| shape.position); let mut result = String::new(); let mut segments: Vec<(usize, usize, Option<&CharShape>)> = Vec::new(); // 구간 정의 / Define segments let mut positions = vec![0]; for shape_info in &sorted_shapes { let pos = shape_info.position as usize; if pos <= text_len { positions.push(pos); } } positions.push(text_len); positions.sort(); positions.dedup(); // 각 구간에 대한 CharShape 찾기 / Find CharShape for each segment for i in 0..positions.len() - 1 { let start = positions[i]; let end = positions[i + 1]; // 이 구간에 적용할 CharShape 찾기 / Find CharShape to apply to this segment // start 위치에서 시작하는 가장 가까운 CharShape를 찾음 / Find the closest CharShape starting at start position let char_shape = sorted_shapes .iter() .find(|shape| (shape.position as usize) == start) .or_else(|| { // 정확히 일치하는 것이 없으면, start보다 작은 position 중 가장 큰 것을 찾음 // If no exact match, find the largest position less than start sorted_shapes .iter() .rev() .find(|shape| (shape.position as usize) < start) }) .and_then(|shape| get_char_shape(shape.shape_id)); segments.push((start, end, char_shape)); } // PARA_BREAK/LINE_BREAK 위치 수집 / Collect PARA_BREAK/LINE_BREAK positions let mut break_positions: Vec<usize> = control_positions .iter() .filter(|pos| pos.code == ControlChar::PARA_BREAK || pos.code == ControlChar::LINE_BREAK) .map(|pos| usize::from(pos.position)) .collect(); break_positions.sort(); // 각 구간에 스타일 적용하여 결과 생성 / Generate result by applying styles to each segment for (start, end, char_shape) in &segments { if *start < *end && *end <= text_len { // 이 구간 내에 PARA_BREAK/LINE_BREAK가 있는지 확인 / Check if there are breaks in this segment let mut segment_breaks: Vec<usize> = break_positions .iter() .filter(|&&break_pos| break_pos >= *start && break_pos < *end) .copied() .collect(); if segment_breaks.is_empty() { // 구간 내에 break가 없으면 전체 구간에 스타일 적용 / No breaks in segment, apply style to entire segment let segment_text: String = text_chars[*start..*end].iter().collect(); if !segment_text.trim().is_empty() { if let Some(shape) = char_shape { let styled = apply_markdown_styles( &segment_text, shape.attributes.bold, shape.attributes.italic, shape.attributes.strikethrough != 0, ); result.push_str(&styled); } else { result.push_str(&segment_text); } } } else { // 구간 내에 break가 있으면 break 위치로 나누어 처리 / Split segment by breaks segment_breaks.insert(0, *start); segment_breaks.push(*end); for i in 0..segment_breaks.len() - 1 { let seg_start = segment_breaks[i]; let seg_end = segment_breaks[i + 1]; if seg_start < seg_end && seg_end <= text_len { let segment_text: String = text_chars[seg_start..seg_end].iter().collect(); if !segment_text.trim().is_empty() { if let Some(shape) = char_shape { let styled = apply_markdown_styles( &segment_text, shape.attributes.bold, shape.attributes.italic, shape.attributes.strikethrough != 0, ); result.push_str(&styled); } else { result.push_str(&segment_text); } } } // break 다음이면 마크다운 개행 추가 / Add markdown line break after break if i < segment_breaks.len() - 2 { result.push_str(" \n"); } } } } } let trimmed_result = result.trim(); if !trimmed_result.is_empty() { Some(trimmed_result.to_string()) } else { None } } /// 텍스트에 마크다운 스타일을 적용합니다. / Apply markdown styles to text. /// /// # Arguments / 매개변수 /// * `text` - 원본 텍스트 / Original text /// * `bold` - 진하게 여부 / Bold /// * `italic` - 기울임 여부 / Italic /// * `strikethrough` - 가운뎃줄 여부 / Strikethrough /// /// # Returns / 반환값 /// 마크다운 스타일이 적용된 텍스트 / Text with markdown styles applied fn apply_markdown_styles(text: &str, bold: bool, italic: bool, strikethrough: bool) -> String { if text.is_empty() { return String::new(); } let mut result = String::from(text); // 마크다운 스타일 적용 순서: strikethrough (가장 바깥) -> bold -> italic (가장 안쪽) // Markdown style application order: strikethrough (outermost) -> bold -> italic (innermost) // 기울임 적용 (가장 안쪽) / Apply italic (innermost) if italic { result = format!("*{}*", result); } // 진하게 적용 / Apply bold if bold { result = format!("**{}**", result); } // 가운뎃줄 적용 (가장 바깥쪽) / Apply strikethrough (outermost) if strikethrough { result = format!("~~{}~~", result); } result } pub fn convert_para_text_to_markdown( text: &str, control_positions: &[ControlCharPosition], ) -> Option<String> { convert_para_text_to_markdown_with_char_shapes(text, control_positions, &[], None) } /// CharShape 정보를 사용하여 ParaText를 마크다운으로 변환 /// Convert ParaText to markdown using CharShape information /// /// # Arguments / 매개변수 /// * `text` - 텍스트 내용 / Text content /// * `control_positions` - 제어 문자 위치 정보 / Control character positions /// * `char_shapes` - 글자 모양 정보 리스트 / Character shape information list /// * `get_char_shape` - shape_id로 CharShape를 가져오는 함수 / Function to get CharShape by shape_id /// /// # Returns / 반환값 /// 마크다운 문자열 / Markdown string pub fn convert_para_text_to_markdown_with_char_shapes<'a>( text: &str, control_positions: &[ControlCharPosition], char_shapes: &[CharShapeInfo], get_char_shape: Option<&'a dyn Fn(u32) -> Option<&'a CharShape>>, ) -> Option<String> { // CharShape 정보가 있으면 텍스트를 구간별로 나누어 스타일 적용 / If CharShape info exists, divide text into segments and apply styles if !char_shapes.is_empty() && get_char_shape.is_some() { return convert_text_with_char_shapes( text, control_positions, char_shapes, get_char_shape.unwrap(), ); } // PARA_BREAK나 LINE_BREAK가 있는지 확인 / Check for PARA_BREAK or LINE_BREAK let has_breaks = control_positions .iter() .any(|pos| pos.code == ControlChar::PARA_BREAK || pos.code == ControlChar::LINE_BREAK); if !has_breaks { // 제어 문자가 없으면 기존 로직 사용 / Use existing logic if no control characters if is_meaningful_text(text, control_positions) { let trimmed = text.trim(); if !trimmed.is_empty() { return Some(trimmed.to_string()); } } return None; } // PARA_BREAK/LINE_BREAK가 있는 경우 처리 / Process when PARA_BREAK/LINE_BREAK exists // 파서에서 \n을 제거했으므로, control_positions의 정보만 사용하여 마크다운 개행으로 변환 // Parser removed \n, so only use control_positions info to convert to markdown line breaks let mut result = String::new(); let mut last_char_pos = 0; // control_positions를 정렬하여 순서대로 처리 / Sort control_positions to process in order let mut sorted_positions: Vec<_> = control_positions.iter().collect(); sorted_positions.sort_by_key(|pos| pos.position); for pos in sorted_positions { // PARA_BREAK나 LINE_BREAK만 처리 / Only process PARA_BREAK or LINE_BREAK if pos.code != ControlChar::PARA_BREAK && pos.code != ControlChar::LINE_BREAK { continue; } // 문자 인덱스를 바이트 인덱스로 변환 / Convert character index to byte index let byte_idx = match char_index_to_byte_index(text, pos.position) { Some(idx) => idx, None => continue, // 유효하지 않은 위치는 건너뜀 / Skip invalid position }; let last_byte_idx = char_index_to_byte_index(text, last_char_pos).unwrap_or(0); // 제어 문자 이전의 텍스트 추가 (파서에서 \n이 제거되었으므로 그대로 사용) // Add text before control character (parser removed \n, so use as-is) if byte_idx > last_byte_idx && byte_idx <= text.len() { let text_part = &text[last_byte_idx..byte_idx]; let trimmed = text_part.trim(); if !trimmed.is_empty() { result.push_str(trimmed); } } // PARA_BREAK나 LINE_BREAK를 마크다운 개행(스페이스 2개 + 개행)으로 변환 // Convert PARA_BREAK or LINE_BREAK to markdown line break (two spaces + newline) result.push_str(" \n"); // 제어 문자 다음 위치 / Position after control character last_char_pos = pos.position + 1; } // 마지막 부분의 텍스트 추가 / Add remaining text let last_byte_idx = char_index_to_byte_index(text, last_char_pos).unwrap_or(0); if last_byte_idx < text.len() { let text_part = &text[last_byte_idx..]; let trimmed = text_part.trim(); if !trimmed.is_empty() { result.push_str(trimmed); } } // trim() 대신 trim_start()만 사용하여 줄 끝 공백(마크다운 개행용)은 유지 // Use trim_start() instead of trim() to preserve trailing spaces (for markdown line breaks) let trimmed_result = result.trim_start(); if !trimmed_result.is_empty() { Some(trimmed_result.to_string()) } else { None } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/preview_image.rs

crates/hwp-core/src/document/preview_image.rs

/// PreviewImage 구조체 / PreviewImage structure /// /// 스펙 문서 매핑: 3.2.7 - 미리보기 이미지 / Spec mapping: 3.2.7 - Preview image /// /// `PrvImage` 스트림에는 미리보기 이미지가 BMP 또는 GIF 형식으로 저장됩니다. /// The `PrvImage` stream contains preview image stored as BMP or GIF format. use crate::error::HwpError; use base64::{engine::general_purpose::STANDARD, Engine as _}; use serde::{Deserialize, Serialize}; use std::path::Path; /// 미리보기 이미지 / Preview image #[derive(Debug, Clone, Serialize, Deserialize)] pub struct PreviewImage { /// Base64로 인코딩된 이미지 데이터 / Base64 encoded image data pub data: String, /// 이미지 형식 ("BMP" 또는 "GIF") / Image format ("BMP" or "GIF") pub format: String, /// 파일로 저장된 경우 파일 경로 (선택적) / File path if saved as file (optional) #[serde(skip_serializing_if = "Option::is_none")] pub file_path: Option<String>, } impl PreviewImage { /// PreviewImage를 바이트 배열에서 파싱합니다. / Parse PreviewImage from byte array. /// /// # Arguments /// * `data` - PrvImage 스트림의 원시 바이트 데이터 / Raw byte data of PrvImage stream /// * `save_to_file` - 파일로 저장할 디렉토리 경로 (선택적) / Optional directory path to save file /// /// # Returns /// 파싱된 PreviewImage 구조체 / Parsed PreviewImage structure /// /// # Note /// 스펙 문서 3.2.7에 따르면 PrvImage 스트림에는 미리보기 이미지가 BMP 또는 GIF 형식으로 저장됩니다. /// According to spec 3.2.7, the PrvImage stream contains preview image stored as BMP or GIF format. /// 이미지 형식은 파일 시그니처를 확인하여 감지합니다. /// Image format is detected by checking file signature. /// 이미지 데이터는 항상 base64로 인코딩되어 저장되며, 선택적으로 파일로도 저장할 수 있습니다. /// Image data is always stored as base64 encoded string, and optionally saved as file. pub fn parse(data: &[u8], save_to_file: Option<&str>) -> Result<Self, HwpError> { if data.is_empty() { return Err(HwpError::InsufficientData { field: "PreviewImage data".to_string(), expected: 1, actual: 0, }); } // 이미지 형식 감지 / Detect image format // BMP: "BM" (0x42 0x4D)로 시작 / BMP: starts with "BM" (0x42 0x4D) // GIF: "GIF87a" 또는 "GIF89a"로 시작 / GIF: starts with "GIF87a" or "GIF89a" let format = if data.len() >= 2 && data[0] == 0x42 && data[1] == 0x4D { "BMP".to_string() } else if data.len() >= 6 { let gif_header = &data[0..6]; if gif_header == b"GIF87a" || gif_header == b"GIF89a" { "GIF".to_string() } else { // 알 수 없는 형식이지만 데이터는 저장 / Unknown format but store data "UNKNOWN".to_string() } } else { // 데이터가 너무 짧아서 형식을 확인할 수 없음 / Data too short to determine format "UNKNOWN".to_string() }; // Base64 인코딩 / Base64 encoding let base64_data = STANDARD.encode(data); // 파일로 저장 (선택적) / Save to file (optional) let file_path = if let Some(dir_path) = save_to_file { let extension = match format.as_str() { "BMP" => "bmp", "GIF" => "gif", _ => "bin", }; let file_name = format!("preview_image.{}", extension); let file_path = Path::new(dir_path).join(&file_name); std::fs::create_dir_all(dir_path).map_err(|e| { HwpError::Io(format!("Failed to create directory '{}': {}", dir_path, e)) })?; std::fs::write(&file_path, data).map_err(|e| { HwpError::Io(format!( "Failed to write preview image file '{}': {}", file_path.display(), e )) })?; Some(file_path.to_string_lossy().to_string()) } else { None }; Ok(PreviewImage { data: base64_data, format, file_path, }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/preview_text.rs

crates/hwp-core/src/document/preview_text.rs

/// PreviewText 구조체 / PreviewText structure /// /// 스펙 문서 매핑: 3.2.6 - 미리보기 텍스트 / Spec mapping: 3.2.6 - Preview text /// /// `PrvText` 스트림에는 미리보기 텍스트가 유니코드 문자열로 저장됩니다. /// The `PrvText` stream contains preview text stored as Unicode string. use crate::error::HwpError; use crate::types::decode_utf16le; use serde::{Deserialize, Serialize}; /// 미리보기 텍스트 / Preview text #[derive(Debug, Clone, Serialize, Deserialize)] pub struct PreviewText { /// 미리보기 텍스트 내용 (UTF-16LE) / Preview text content (UTF-16LE) pub text: String, } impl PreviewText { /// PreviewText를 바이트 배열에서 파싱합니다. / Parse PreviewText from byte array. /// /// # Arguments /// * `data` - PrvText 스트림의 원시 바이트 데이터 / Raw byte data of PrvText stream /// /// # Returns /// 파싱된 PreviewText 구조체 / Parsed PreviewText structure /// /// # Note /// 스펙 문서 3.2.6에 따르면 PrvText 스트림에는 미리보기 텍스트가 유니코드 문자열로 저장됩니다. /// According to spec 3.2.6, the PrvText stream contains preview text stored as Unicode string. /// UTF-16LE 형식으로 저장되므로 decode_utf16le 함수를 사용하여 디코딩합니다. /// Since it's stored in UTF-16LE format, we use decode_utf16le function to decode it. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // UTF-16LE 디코딩 / Decode UTF-16LE let text = decode_utf16le(data) .map_err(|e| HwpError::EncodingError { reason: format!("Failed to decode preview text: {}", e), })?; Ok(PreviewText { text }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/xml_template.rs

crates/hwp-core/src/document/xml_template.rs

/// XmlTemplate 구조체 / XmlTemplate structure /// /// 스펙 문서 매핑: 3.2.10 - XML 템플릿 / Spec mapping: 3.2.10 - XML Template /// /// `XMLTemplate` 스토리지에는 XML Template 정보가 저장됩니다. /// The `XMLTemplate` storage contains XML Template information. use crate::cfb::CfbParser; use crate::error::HwpError; use crate::types::{decode_utf16le, DWORD}; use serde::{Deserialize, Serialize}; /// XML 템플릿 / XML Template #[derive(Debug, Clone, Default, Serialize, Deserialize)] pub struct XmlTemplate { /// Schema 이름 (from _SchemaName stream) / Schema name (from _SchemaName stream) #[serde(skip_serializing_if = "Option::is_none")] pub schema_name: Option<String>, /// Schema (from Schema stream) / Schema (from Schema stream) #[serde(skip_serializing_if = "Option::is_none")] pub schema: Option<String>, /// Instance (from Instance stream) / Instance (from Instance stream) #[serde(skip_serializing_if = "Option::is_none")] pub instance: Option<String>, } impl XmlTemplate { /// XmlTemplate을 CFB 구조에서 파싱합니다. / Parse XmlTemplate from CFB structure. /// /// # Arguments /// * `cfb` - CompoundFile structure (mutable reference required) / CompoundFile 구조체 (가변 참조 필요) /// /// # Returns /// 파싱된 XmlTemplate 구조체 / Parsed XmlTemplate structure /// /// # Note /// 스펙 문서 3.2.10에 따르면 XMLTemplate 스토리지에는 다음 스트림이 포함됩니다: /// - _SchemaName: Schema 이름 (표 10) /// - Schema: Schema 문자열 (표 11) /// - Instance: Instance 문자열 (표 12) /// According to spec 3.2.10, XMLTemplate storage contains the following streams: /// - _SchemaName: Schema name (Table 10) /// - Schema: Schema string (Table 11) /// - Instance: Instance string (Table 12) pub fn parse(cfb: &mut cfb::CompoundFile<std::io::Cursor<&[u8]>>) -> Result<Self, HwpError> { let mut xml_template = XmlTemplate::default(); // Parse _SchemaName stream // _SchemaName 스트림 파싱 / Parse _SchemaName stream // 스펙 문서 표 10: Schema 이름 정보 // Spec Table 10: Schema name information if let Ok(schema_name_data) = CfbParser::read_nested_stream(cfb, "XMLTemplate", "_SchemaName") { match Self::parse_schema_name(&schema_name_data) { Ok(schema_name) => { xml_template.schema_name = Some(schema_name); } Err(e) => { #[cfg(debug_assertions)] eprintln!("Warning: Failed to parse _SchemaName stream: {}", e); } } } // Parse Schema stream // Schema 스트림 파싱 / Parse Schema stream // 스펙 문서 표 11: Schema 길이 정보 // Spec Table 11: Schema length information if let Ok(schema_data) = CfbParser::read_nested_stream(cfb, "XMLTemplate", "Schema") { match Self::parse_schema(&schema_data) { Ok(schema) => { xml_template.schema = Some(schema); } Err(e) => { #[cfg(debug_assertions)] eprintln!("Warning: Failed to parse Schema stream: {}", e); } } } // Parse Instance stream // Instance 스트림 파싱 / Parse Instance stream // 스펙 문서 표 12: Instance 정보 // Spec Table 12: Instance information if let Ok(instance_data) = CfbParser::read_nested_stream(cfb, "XMLTemplate", "Instance") { match Self::parse_instance(&instance_data) { Ok(instance) => { xml_template.instance = Some(instance); } Err(e) => { #[cfg(debug_assertions)] eprintln!("Warning: Failed to parse Instance stream: {}", e); } } } Ok(xml_template) } /// Schema 이름 파싱 (표 10) / Parse schema name (Table 10) fn parse_schema_name(data: &[u8]) -> Result<String, HwpError> { if data.len() < 4 { return Err(HwpError::insufficient_data( "Schema name data", 4, data.len(), )); } // DWORD Schema 이름 길이 (4 bytes) / Schema name length (4 bytes) let len = DWORD::from_le_bytes([data[0], data[1], data[2], data[3]]) as usize; // WCHAR array[len] Schema 이름 (2×len bytes) / Schema name (2×len bytes) if data.len() < 4 + (len * 2) { return Err(HwpError::InsufficientData { field: "Schema name data".to_string(), expected: 4 + (len * 2), actual: data.len(), }); } if len > 0 { let schema_name_bytes = &data[4..4 + (len * 2)]; decode_utf16le(schema_name_bytes).map_err(|e| HwpError::EncodingError { reason: format!("Failed to decode schema name: {}", e), }) } else { Ok(String::new()) } } /// Schema 파싱 (표 11) / Parse schema (Table 11) fn parse_schema(data: &[u8]) -> Result<String, HwpError> { if data.len() < 4 { return Err(HwpError::insufficient_data("Schema data", 4, data.len())); } // DWORD Schema 길이 (4 bytes) / Schema length (4 bytes) let len = DWORD::from_le_bytes([data[0], data[1], data[2], data[3]]) as usize; // WCHAR array[len] Schema (2×len bytes) / Schema (2×len bytes) if data.len() < 4 + (len * 2) { return Err(HwpError::InsufficientData { field: "Schema data".to_string(), expected: 4 + (len * 2), actual: data.len(), }); } if len > 0 { let schema_bytes = &data[4..4 + (len * 2)]; decode_utf16le(schema_bytes).map_err(|e| HwpError::EncodingError { reason: format!("Failed to decode schema: {}", e), }) } else { Ok(String::new()) } } /// Instance 파싱 (표 12) / Parse instance (Table 12) fn parse_instance(data: &[u8]) -> Result<String, HwpError> { if data.len() < 4 { return Err(HwpError::insufficient_data("Instance data", 4, data.len())); } // DWORD Instance 길이 (4 bytes) / Instance length (4 bytes) let len = DWORD::from_le_bytes([data[0], data[1], data[2], data[3]]) as usize; // WCHAR array[len] Instance (2×len bytes) / Instance (2×len bytes) if data.len() < 4 + (len * 2) { return Err(HwpError::InsufficientData { field: "Instance data".to_string(), expected: 4 + (len * 2), actual: data.len(), }); } if len > 0 { let instance_bytes = &data[4..4 + (len * 2)]; decode_utf16le(instance_bytes).map_err(|e| HwpError::EncodingError { reason: format!("Failed to decode instance: {}", e), }) } else { Ok(String::new()) } } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/mod.rs

crates/hwp-core/src/document/mod.rs

pub mod bindata; pub mod bodytext; pub mod constants; pub mod docinfo; /// HWP Document structure /// /// This module defines the main document structure for HWP files. /// /// 스펙 문서 매핑: 표 2 - 전체 구조 pub mod fileheader; pub mod preview_image; pub mod preview_text; pub mod scripts; pub mod summary_information; pub mod xml_template; pub use bindata::{BinData, BinaryDataFormat}; pub use bodytext::{ BodyText, ColumnDivideType, CtrlHeader, CtrlHeaderData, CtrlId, PageNumberPosition, Paragraph, ParagraphRecord, Section, }; pub use docinfo::{ BinDataRecord, BorderFill, Bullet, CharShape, DocInfo, DocumentProperties, FaceName, FillInfo, HeaderShapeType, IdMappings, Numbering, ParaShape, Style, TabDef, }; pub use fileheader::FileHeader; pub use preview_image::PreviewImage; pub use preview_text::PreviewText; pub use scripts::Scripts; pub use summary_information::SummaryInformation; pub use xml_template::XmlTemplate; use serde::{Deserialize, Serialize}; /// Main HWP document structure #[derive(Debug, Clone, Serialize, Deserialize)] pub struct HwpDocument { /// File header information pub file_header: FileHeader, /// Document information (DocInfo stream) pub doc_info: DocInfo, /// Body text (BodyText storage) pub body_text: BodyText, /// Binary data (BinData storage) pub bin_data: BinData, /// Preview text (PrvText stream) pub preview_text: Option<PreviewText>, /// Preview image (PrvImage stream) pub preview_image: Option<PreviewImage>, /// Scripts (Scripts storage) pub scripts: Option<Scripts>, /// XML Template (XMLTemplate storage) pub xml_template: Option<XmlTemplate>, /// Summary Information (\005HwpSummaryInformation stream) pub summary_information: Option<SummaryInformation>, } impl HwpDocument { /// Create a new empty HWP document pub fn new(file_header: FileHeader) -> Self { Self { file_header, doc_info: DocInfo::default(), body_text: BodyText::default(), bin_data: BinData::default(), preview_text: None, preview_image: None, scripts: None, xml_template: None, summary_information: None, } } /// Convert HWP document to Markdown format /// HWP 문서를 마크다운 형식으로 변환 /// /// # Arguments / 매개변수 /// * `options` - Markdown conversion options / 마크다운 변환 옵션 /// /// # Returns / 반환값 /// Markdown string representation of the document / 문서의 마크다운 문자열 표현 pub fn to_markdown(&self, options: &crate::viewer::markdown::MarkdownOptions) -> String { crate::viewer::to_markdown(self, options) } /// Convert HWP document to Markdown format (기존 API 호환성) /// HWP 문서를 마크다운 형식으로 변환 (기존 API 호환성) /// /// # Arguments / 매개변수 /// * `image_output_dir` - Optional directory path to save images as files. If None, images are embedded as base64 data URIs. /// 이미지를 파일로 저장할 디렉토리 경로 (선택). None이면 base64 데이터 URI로 임베드됩니다. /// /// # Returns / 반환값 /// Markdown string representation of the document / 문서의 마크다운 문자열 표현 pub fn to_markdown_with_dir(&self, image_output_dir: Option<&str>) -> String { let options = crate::viewer::markdown::MarkdownOptions { image_output_dir: image_output_dir.map(|s| s.to_string()), use_html: Some(true), include_version: Some(true), include_page_info: Some(true), }; crate::viewer::to_markdown(self, &options) } /// Convert HWP document to HTML format /// HWP 문서를 HTML 형식으로 변환 /// /// # Arguments / 매개변수 /// * `options` - HTML conversion options / HTML 변환 옵션 /// /// # Returns / 반환값 /// HTML string representation of the document / 문서의 HTML 문자열 표현 pub fn to_html(&self, options: &crate::viewer::html::HtmlOptions) -> String { crate::viewer::to_html(self, options) } /// Resolve derived display texts for control tokens (e.g., AUTO_NUMBER) into `ParaTextRun::Control.display_text`. /// /// IMPORTANT: /// - `runs` (control tokens + document settings) are the source of truth. /// - `display_text` is a derived/cache value for preview/viewers and may be recomputed. pub fn resolve_display_texts(&mut self) { use crate::document::bodytext::{ControlChar, ParaTextRun}; use crate::document::ParagraphRecord; // Footnote/endnote numbering rules are defined by FootnoteShape (spec Table 133/134). // In practice, two FootnoteShape records appear (footnote, endnote). If only one exists, // we reuse it for both. let mut footnote_shape_opt: Option<crate::document::bodytext::FootnoteShape> = None; let mut endnote_shape_opt: Option<crate::document::bodytext::FootnoteShape> = None; for section in &self.body_text.sections { for paragraph in &section.paragraphs { for record in &paragraph.records { if let ParagraphRecord::FootnoteShape { footnote_shape } = record { if footnote_shape_opt.is_none() { footnote_shape_opt = Some(footnote_shape.clone()); } else if endnote_shape_opt.is_none() { endnote_shape_opt = Some(footnote_shape.clone()); } } } } } if endnote_shape_opt.is_none() { endnote_shape_opt = footnote_shape_opt.clone(); } let mut table_no: u32 = self .doc_info .document_properties .as_ref() .map(|p| p.table_start_number as u32) .unwrap_or(1); let footnote_start: u32 = footnote_shape_opt .as_ref() .map(|s| s.start_number as u32) .or_else(|| { self.doc_info .document_properties .as_ref() .map(|p| p.footnote_start_number as u32) }) .unwrap_or(1); let endnote_start: u32 = endnote_shape_opt .as_ref() .map(|s| s.start_number as u32) .or_else(|| { self.doc_info .document_properties .as_ref() .map(|p| p.endnote_start_number as u32) }) .unwrap_or(1); let footnote_numbering = footnote_shape_opt .as_ref() .map(|s| s.attributes.numbering) .unwrap_or(crate::document::bodytext::footnote_shape::NumberingMethod::Continue); let endnote_numbering = endnote_shape_opt .as_ref() .map(|s| s.attributes.numbering) .unwrap_or(crate::document::bodytext::footnote_shape::NumberingMethod::Continue); // NOTE: PerPage is currently treated the same as Continue (requested). let mut footnote_no: u32 = footnote_start; let mut endnote_no: u32 = endnote_start; let mut image_no: u32 = self .doc_info .document_properties .as_ref() .map(|p| p.image_start_number as u32) .unwrap_or(1); let mut formula_no: u32 = self .doc_info .document_properties .as_ref() .map(|p| p.formula_start_number as u32) .unwrap_or(1); #[derive(Debug, Clone, Copy, PartialEq, Eq)] enum AutoNumberKind { Page = 0, Footnote = 1, Endnote = 2, Image = 3, Table = 4, Formula = 5, Unknown = 255, } fn parse_auto_number_kind(attribute: u32) -> AutoNumberKind { match (attribute & 0x0F) as u8 { 0 => AutoNumberKind::Page, 1 => AutoNumberKind::Footnote, 2 => AutoNumberKind::Endnote, 3 => AutoNumberKind::Image, 4 => AutoNumberKind::Table, 5 => AutoNumberKind::Formula, _ => AutoNumberKind::Unknown, } } fn parse_number_shape( attribute: u32, ) -> crate::document::bodytext::footnote_shape::NumberShape { // spec Table 143 bit 4-11 number shape, mapping uses Table 134 (same as FootnoteShape) let v = ((attribute >> 4) & 0xFF) as u8; use crate::document::bodytext::footnote_shape::NumberShape; match v { 0 => NumberShape::Arabic, 1 => NumberShape::CircledArabic, 2 => NumberShape::RomanUpper, 3 => NumberShape::RomanLower, 4 => NumberShape::AlphaUpper, 5 => NumberShape::AlphaLower, 6 => NumberShape::CircledAlphaUpper, 7 => NumberShape::CircledAlphaLower, 8 => NumberShape::Hangul, 9 => NumberShape::CircledHangul, 10 => NumberShape::HangulJamo, 11 => NumberShape::CircledHangulJamo, 12 => NumberShape::HangulNumber, 13 => NumberShape::ChineseNumber, 14 => NumberShape::CircledChineseNumber, 15 => NumberShape::HeavenlyStem, 16 => NumberShape::HeavenlyStemChinese, 0x80 => NumberShape::FourCharRepeat, 0x81 => NumberShape::CustomCharRepeat, _ => NumberShape::Arabic, } } fn format_number( shape: crate::document::bodytext::footnote_shape::NumberShape, n: u32, ) -> String { use crate::document::bodytext::footnote_shape::NumberShape; match shape { NumberShape::Arabic => n.to_string(), NumberShape::RomanUpper => to_roman(n).to_uppercase(), NumberShape::RomanLower => to_roman(n).to_lowercase(), NumberShape::AlphaUpper => to_alpha(n, true), NumberShape::AlphaLower => to_alpha(n, false), NumberShape::CircledArabic => circled_number(n).unwrap_or_else(|| n.to_string()), NumberShape::CircledAlphaUpper => { circled_alpha(n, true).unwrap_or_else(|| to_alpha(n, true)) } NumberShape::CircledAlphaLower => { circled_alpha(n, false).unwrap_or_else(|| to_alpha(n, false)) } NumberShape::Hangul => hangul_gana(n).unwrap_or_else(|| n.to_string()), NumberShape::HangulJamo => hangul_jamo(n).unwrap_or_else(|| n.to_string()), NumberShape::CircledHangul => circled_hangul_gana(n) .unwrap_or_else(|| hangul_gana(n).unwrap_or_else(|| n.to_string())), NumberShape::CircledHangulJamo => circled_hangul_jamo(n) .unwrap_or_else(|| hangul_jamo(n).unwrap_or_else(|| n.to_string())), NumberShape::HangulNumber => hangul_number(n).unwrap_or_else(|| n.to_string()), NumberShape::ChineseNumber => chinese_number(n).unwrap_or_else(|| n.to_string()), NumberShape::CircledChineseNumber => circled_chinese_number(n) .unwrap_or_else(|| chinese_number(n).unwrap_or_else(|| n.to_string())), NumberShape::HeavenlyStem => heavenly_stem(n).unwrap_or_else(|| n.to_string()), NumberShape::HeavenlyStemChinese => { heavenly_stem_chinese(n).unwrap_or_else(|| n.to_string()) } // NOTE: Repeat-based shapes require additional spec-backed inputs (e.g., custom symbol set). // We intentionally fall back to Arabic until we can resolve the exact behavior from spec/fixtures. NumberShape::FourCharRepeat | NumberShape::CustomCharRepeat => n.to_string(), } } fn circled_number(n: u32) -> Option<String> { // ①..⑳ (U+2460..U+2473) for 1..20 if (1..=20).contains(&n) { let cp = 0x2460 + (n - 1); return char::from_u32(cp).map(|c| c.to_string()); } // ㉑..㉟ (U+3251..U+325F) for 21..35 (circled numbers in a circle) if (21..=35).contains(&n) { let cp = 0x3251 + (n - 21); return char::from_u32(cp).map(|c| c.to_string()); } None } fn circled_alpha(n: u32, upper: bool) -> Option<String> { // Ⓐ..Ⓩ (U+24B6..U+24CF) for 1..26 // ⓐ..ⓩ (U+24D0..U+24E9) for 1..26 if !(1..=26).contains(&n) { return None; } let base = if upper { 0x24B6 } else { 0x24D0 }; let cp = base + (n - 1); char::from_u32(cp).map(|c| c.to_string()) } fn hangul_gana(n: u32) -> Option<String> { // 가..하 (14 chars) used commonly for numbering const LIST: [&str; 14] = [ "가", "나", "다", "라", "마", "바", "사", "아", "자", "차", "카", "타", "파", "하", ]; if n == 0 { return None; } let idx = ((n - 1) % (LIST.len() as u32)) as usize; Some(LIST[idx].to_string()) } fn circled_hangul_gana(n: u32) -> Option<String> { // ㉮..㉻ (U+326E..U+327B) for 1..14 if !(1..=14).contains(&n) { return None; } let cp = 0x326E + (n - 1); char::from_u32(cp).map(|c| c.to_string()) } fn hangul_jamo(n: u32) -> Option<String> { // ㄱ ㄴ ㄷ ㄹ ㅁ ㅂ ㅅ ㅇ ㅈ ㅊ ㅋ ㅌ ㅍ ㅎ const LIST: [&str; 14] = [ "ㄱ", "ㄴ", "ㄷ", "ㄹ", "ㅁ", "ㅂ", "ㅅ", "ㅇ", "ㅈ", "ㅊ", "ㅋ", "ㅌ", "ㅍ", "ㅎ", ]; if n == 0 { return None; } let idx = ((n - 1) % (LIST.len() as u32)) as usize; Some(LIST[idx].to_string()) } fn circled_hangul_jamo(n: u32) -> Option<String> { // ㉠..㉭ (U+3260..U+326D) for 1..14 if !(1..=14).contains(&n) { return None; } let cp = 0x3260 + (n - 1); char::from_u32(cp).map(|c| c.to_string()) } fn hangul_number(n: u32) -> Option<String> { // 일, 이, 삼 ... (up to 99 for now) if n == 0 || n > 99 { return None; } const DIGITS: [&str; 10] = ["", "일", "이", "삼", "사", "오", "육", "칠", "팔", "구"]; if n < 10 { return Some(DIGITS[n as usize].to_string()); } if n == 10 { return Some("십".to_string()); } let tens = n / 10; let ones = n % 10; let mut out = String::new(); if tens > 1 { out.push_str(DIGITS[tens as usize]); } out.push('십'); if ones > 0 { out.push_str(DIGITS[ones as usize]); } Some(out) } fn chinese_number(n: u32) -> Option<String> { // 一, 二, 三 ... (up to 99 for now) if n == 0 || n > 99 { return None; } const DIGITS: [&str; 10] = ["", "一", "二", "三", "四", "五", "六", "七", "八", "九"]; if n < 10 { return Some(DIGITS[n as usize].to_string()); } if n == 10 { return Some("十".to_string()); } let tens = n / 10; let ones = n % 10; let mut out = String::new(); if tens > 1 { out.push_str(DIGITS[tens as usize]); } out.push('十'); if ones > 0 { out.push_str(DIGITS[ones as usize]); } Some(out) } fn circled_chinese_number(n: u32) -> Option<String> { // ㊀..㊉ (U+3280..U+3289) for 1..10 if !(1..=10).contains(&n) { return None; } let cp = 0x3280 + (n - 1); char::from_u32(cp).map(|c| c.to_string()) } fn heavenly_stem(n: u32) -> Option<String> { // 갑, 을, 병, 정, 무, 기, 경, 신, 임, 계 const LIST: [&str; 10] = ["갑", "을", "병", "정", "무", "기", "경", "신", "임", "계"]; if n == 0 { return None; } let idx = ((n - 1) % 10) as usize; Some(LIST[idx].to_string()) } fn heavenly_stem_chinese(n: u32) -> Option<String> { // 甲, 乙, 丙, 丁, 戊, 己, 庚, 辛, 壬, 癸 const LIST: [&str; 10] = ["甲", "乙", "丙", "丁", "戊", "己", "庚", "辛", "壬", "癸"]; if n == 0 { return None; } let idx = ((n - 1) % 10) as usize; Some(LIST[idx].to_string()) } fn to_roman(mut n: u32) -> String { if n == 0 { return String::new(); } let mut out = String::new(); let pairs = [ (1000, "M"), (900, "CM"), (500, "D"), (400, "CD"), (100, "C"), (90, "XC"), (50, "L"), (40, "XL"), (10, "X"), (9, "IX"), (5, "V"), (4, "IV"), (1, "I"), ]; for (v, s) in pairs { while n >= v { out.push_str(s); n -= v; } } out } fn to_alpha(mut n: u32, upper: bool) -> String { // 1->A, 26->Z, 27->AA if n == 0 { return String::new(); } let mut buf: Vec<u8> = Vec::new(); while n > 0 { n -= 1; let c = (n % 26) as u8; buf.push(if upper { b'A' + c } else { b'a' + c }); n /= 26; } buf.reverse(); String::from_utf8_lossy(&buf).to_string() } fn resolve_paragraph_record( record: &mut ParagraphRecord, table_no: &mut u32, footnote_no: &mut u32, endnote_no: &mut u32, _image_no: &mut u32, _formula_no: &mut u32, ) { match record { ParagraphRecord::CtrlHeader { header, children, paragraphs, .. } => { // Footnote/endnote ctrl headers ("fn " / "en "): assign number to all AUTO_NUMBER tokens in this subtree. if header.ctrl_id == "fn " || header.ctrl_id == "en " { let current = if header.ctrl_id == "fn " { *footnote_no } else { *endnote_no }; fn fill_auto_numbers_in_records( records: &mut [ParagraphRecord], value: u32, ) { for r in records.iter_mut() { match r { ParagraphRecord::ParaText { runs, .. } => { for run in runs.iter_mut() { if let ParaTextRun::Control { code, display_text, .. } = run { if *code == ControlChar::AUTO_NUMBER && display_text.is_none() { *display_text = Some(value.to_string()); } } } } ParagraphRecord::CtrlHeader { children, paragraphs, .. } => { fill_auto_numbers_in_records(children, value); for p in paragraphs.iter_mut() { fill_auto_numbers_in_records(&mut p.records, value); } } ParagraphRecord::ListHeader { paragraphs, .. } => { for p in paragraphs.iter_mut() { fill_auto_numbers_in_records(&mut p.records, value); } } ParagraphRecord::ShapeComponent { children, .. } => { fill_auto_numbers_in_records(children, value); } _ => {} } } } fill_auto_numbers_in_records(children, current); for p in paragraphs.iter_mut() { fill_auto_numbers_in_records(&mut p.records, current); } if header.ctrl_id == "fn " { *footnote_no += 1; } else { *endnote_no += 1; } } // Table ctrl header ("tbl "): assign table number to the first AUTO_NUMBER found in caption paragraphs. if header.ctrl_id == "tbl " { let mut assigned_for_this_table = false; for p in paragraphs.iter_mut() { for r in p.records.iter_mut() { if let ParagraphRecord::ParaText { runs, .. } = r { for run in runs.iter_mut() { if let ParaTextRun::Control { code, display_text, .. } = run { if *code == ControlChar::AUTO_NUMBER && display_text.is_none() { *display_text = Some(table_no.to_string()); assigned_for_this_table = true; break; } } } } if assigned_for_this_table { break; } } if assigned_for_this_table { break; } } if assigned_for_this_table { *table_no += 1; } } // Recurse into nested structures for completeness. for c in children.iter_mut() { resolve_paragraph_record( c, table_no, footnote_no, endnote_no, _image_no, _formula_no, ); } for p in paragraphs.iter_mut() { for r in p.records.iter_mut() { resolve_paragraph_record( r, table_no, footnote_no, endnote_no, _image_no, _formula_no, ); } } } ParagraphRecord::ListHeader { paragraphs, .. } => { for p in paragraphs.iter_mut() { for r in p.records.iter_mut() { resolve_paragraph_record( r, table_no, footnote_no, endnote_no, _image_no, _formula_no, ); } } } ParagraphRecord::ShapeComponent { children, .. } => { for c in children.iter_mut() { resolve_paragraph_record( c, table_no, footnote_no, endnote_no, _image_no, _formula_no, ); } } _ => {} } } for section in self.body_text.sections.iter_mut() { // Apply "Restart" per section. PerPage is currently treated as Continue. use crate::document::bodytext::footnote_shape::NumberingMethod; if matches!(footnote_numbering, NumberingMethod::Restart) { footnote_no = footnote_start; } if matches!(endnote_numbering, NumberingMethod::Restart) { endnote_no = endnote_start; } for paragraph in section.paragraphs.iter_mut() { // If this paragraph has an AutoNumber/NewNumber ctrl header, use it to resolve AUTO_NUMBER tokens in its ParaText runs. let mut para_auto_attr: Option<u32> = None; let mut para_auto_prefix: Option<String> = None; let mut para_auto_suffix: Option<String> = None; let mut new_number_attr_and_value: Option<(u32, u16)> = None; for record in paragraph.records.iter() { if let ParagraphRecord::CtrlHeader { header, .. } = record { match &header.data { crate::document::bodytext::ctrl_header::CtrlHeaderData::AutoNumber { attribute, prefix, suffix, .. } => { para_auto_attr = Some(*attribute); if !prefix.is_empty() { para_auto_prefix = Some(prefix.clone()); } if !suffix.is_empty() { para_auto_suffix = Some(suffix.clone()); } } crate::document::bodytext::ctrl_header::CtrlHeaderData::NewNumber { attribute, number, } => { new_number_attr_and_value = Some((*attribute, *number)); } _ => {} } } } // Apply NEW_NUMBER to counters (bit 0-3: kind, number: new value) if let Some((attr, num)) = new_number_attr_and_value { match parse_auto_number_kind(attr) { AutoNumberKind::Footnote => footnote_no = num as u32, AutoNumberKind::Endnote => endnote_no = num as u32, AutoNumberKind::Image => image_no = num as u32, AutoNumberKind::Table => table_no = num as u32, AutoNumberKind::Formula => formula_no = num as u32, _ => {} } } // Fill AUTO_NUMBER tokens in this paragraph if we know the kind. if let Some(attr) = para_auto_attr { let kind = parse_auto_number_kind(attr); let shape = parse_number_shape(attr); let prefix = para_auto_prefix.as_deref().unwrap_or(""); let suffix = para_auto_suffix.as_deref().unwrap_or(""); let next_value = match kind { AutoNumberKind::Footnote => Some(footnote_no), AutoNumberKind::Endnote => Some(endnote_no), AutoNumberKind::Image => Some(image_no), AutoNumberKind::Table => Some(table_no), AutoNumberKind::Formula => Some(formula_no), _ => None, }; if let Some(v) = next_value { let formatted = format!("{}{}{}", prefix, format_number(shape, v), suffix); for record in paragraph.records.iter_mut() { if let ParagraphRecord::ParaText { runs, .. } = record { for run in runs.iter_mut() { if let ParaTextRun::Control { code, display_text, .. } = run { if *code == ControlChar::AUTO_NUMBER && display_text.is_none() { *display_text = Some(formatted.clone()); } } } } } // Increment the counter once per paragraph auto-number usage. match kind { AutoNumberKind::Footnote => footnote_no += 1, AutoNumberKind::Endnote => endnote_no += 1, AutoNumberKind::Image => image_no += 1, AutoNumberKind::Table => table_no += 1, AutoNumberKind::Formula => formula_no += 1, _ => {} } } } for record in paragraph.records.iter_mut() { resolve_paragraph_record( record, &mut table_no, &mut footnote_no, &mut endnote_no, &mut image_no, &mut formula_no, ); } } } } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/summary_information.rs

crates/hwp-core/src/document/summary_information.rs

/// SummaryInformation 구조체 / SummaryInformation structure /// /// 스펙 문서 매핑: 3.2.4 - 문서 요약 / Spec mapping: 3.2.4 - Document summary /// /// `\005HwpSummaryInformation` 스트림에는 한글 메뉴의 "파일 - 문서 정보 - 문서 요약"에서 입력한 내용이 저장됩니다. /// The `\005HwpSummaryInformation` stream contains summary information entered from HWP menu "File - Document Info - Document Summary". /// /// Summary Information에 대한 자세한 설명은 MSDN을 참고: /// For detailed description of Summary Information, refer to MSDN: /// - The Summary Information Property Set /// - The DocumentSummaryInformation and UserDefined Property Set /// /// 스펙 문서 표 7: 문서 요약 Property ID 정의 /// Spec document Table 7: Document summary Property ID definitions use crate::error::HwpError; use crate::types::{INT32, UINT32}; use serde::{Deserialize, Serialize}; /// 문서 요약 정보 / Document summary information #[derive(Debug, Clone, Serialize, Deserialize, Default)] pub struct SummaryInformation { /// 제목 / Title (PIDSI_TITLE, 0x00000002) pub title: Option<String>, /// 주제 / Subject (PIDSI_SUBJECT, 0x00000003) pub subject: Option<String>, /// 작성자 / Author (PIDSI_AUTHOR, 0x00000004) pub author: Option<String>, /// 키워드 / Keywords (PIDSI_KEYWORDS, 0x00000005) pub keywords: Option<String>, /// 주석 / Comments (PIDSI_COMMENTS, 0x00000006) pub comments: Option<String>, /// 마지막 저장한 사람 / Last Saved By (PIDSI_LASTAUTHOR, 0x00000008) pub last_saved_by: Option<String>, /// 수정 번호 / Revision Number (PIDSI_REVNUMBER, 0x00000009) pub revision_number: Option<String>, /// 마지막 인쇄 시간 (UTC+9 ISO 8601 형식) / Last Printed (PIDSI_LASTPRINTED, 0x0000000B) (UTC+9 ISO 8601 format) #[serde(skip_serializing_if = "Option::is_none")] pub last_printed: Option<String>, /// 생성 시간/날짜 (UTC+9 ISO 8601 형식) / Create Time/Date (PIDSI_CREATE_DTM, 0x0000000C) (UTC+9 ISO 8601 format) #[serde(skip_serializing_if = "Option::is_none")] pub create_time: Option<String>, /// 마지막 저장 시간/날짜 (UTC+9 ISO 8601 형식) / Last saved Time/Date (PIDSI_LASTSAVE_DTM, 0x0000000D) (UTC+9 ISO 8601 format) #[serde(skip_serializing_if = "Option::is_none")] pub last_saved_time: Option<String>, /// 페이지 수 / Number of Pages (PIDSI_PAGECOUNT, 0x0000000E) pub page_count: Option<INT32>, /// 날짜 문자열 (사용자 정의) / Date String (User define) (HWPPIDSI_DATE_STR, 0x00000014) pub date_string: Option<String>, /// 문단 수 (사용자 정의) / Para Count (User define) (HWPPIDSI_PARACOUNT, 0x00000015) pub para_count: Option<INT32>, } /// FILETIME 구조체 (Windows FILETIME 형식) / FILETIME structure (Windows FILETIME format) /// 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601 (UTC) #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct FileTime { /// Low 32 bits / 하위 32비트 pub low: UINT32, /// High 32 bits / 상위 32비트 pub high: UINT32, } impl FileTime { /// FILETIME을 Unix timestamp (초)로 변환 / Convert FILETIME to Unix timestamp (seconds) pub fn to_unix_timestamp(self) -> i64 { // FILETIME epoch: January 1, 1601 // Unix epoch: January 1, 1970 // Difference: 11644473600 seconds = 0x019DB1DED53E8000 in 100-nanosecond intervals let filetime = ((self.high as u64) << 32) | (self.low as u64); let unix_time = filetime as i64 - 0x019DB1DED53E8000; unix_time / 10_000_000 // Convert from 100-nanosecond intervals to seconds } /// FILETIME을 UTC+9 시간대의 ISO 8601 문자열로 변환 / Convert FILETIME to ISO 8601 string in UTC+9 timezone pub fn to_utc9_string(self) -> String { use std::time::{Duration, UNIX_EPOCH}; let unix_timestamp = self.to_unix_timestamp(); if unix_timestamp < 0 { return "1970-01-01T00:00:00+09:00".to_string(); } let duration = Duration::from_secs(unix_timestamp as u64); let datetime = UNIX_EPOCH + duration; // UTC+9로 변환 (9시간 추가) // Convert to UTC+9 (add 9 hours) let utc9_datetime = datetime + Duration::from_secs(9 * 3600); // ISO 8601 형식으로 변환 (YYYY-MM-DDTHH:MM:SS+09:00) // Convert to ISO 8601 format (YYYY-MM-DDTHH:MM:SS+09:00) let total_secs = utc9_datetime.duration_since(UNIX_EPOCH).unwrap().as_secs(); let days = total_secs / 86400; let secs_in_day = total_secs % 86400; let hours = secs_in_day / 3600; let minutes = (secs_in_day % 3600) / 60; let seconds = secs_in_day % 60; // 1970-01-01부터의 일수로 날짜 계산 // Calculate date from days since 1970-01-01 let mut year = 1970; let mut day_of_year = days as i32; loop { let days_in_year = if is_leap_year(year) { 366 } else { 365 }; if day_of_year < days_in_year { break; } day_of_year -= days_in_year; year += 1; } let mut month = 1; let mut day = day_of_year + 1; let days_in_month = [ 31, if is_leap_year(year) { 29 } else { 28 }, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, ]; for &dim in &days_in_month { if day <= dim { break; } day -= dim; month += 1; } format!( "{:04}-{:02}-{:02}T{:02}:{:02}:{:02}+09:00", year, month, day, hours, minutes, seconds ) } } fn is_leap_year(year: i32) -> bool { year % 4 == 0 && (year % 100 != 0 || year % 400 == 0) } /// Property ID 상수 / Property ID constants mod property_ids { pub const PID_CODEPAGE: u32 = 0x00000001; // Codepage (VT_I2) pub const PIDSI_TITLE: u32 = 0x00000002; pub const PIDSI_SUBJECT: u32 = 0x00000003; pub const PIDSI_AUTHOR: u32 = 0x00000004; pub const PIDSI_KEYWORDS: u32 = 0x00000005; pub const PIDSI_COMMENTS: u32 = 0x00000006; pub const PIDSI_LASTAUTHOR: u32 = 0x00000008; pub const PIDSI_REVNUMBER: u32 = 0x00000009; pub const PIDSI_LASTPRINTED: u32 = 0x0000000B; pub const PIDSI_CREATE_DTM: u32 = 0x0000000C; pub const PIDSI_LASTSAVE_DTM: u32 = 0x0000000D; pub const PIDSI_PAGECOUNT: u32 = 0x0000000E; pub const HWPPIDSI_DATE_STR: u32 = 0x00000014; pub const HWPPIDSI_PARACOUNT: u32 = 0x00000015; } /// VT (Variant Type) 상수 / VT (Variant Type) constants /// 내부 사용 전용 / Internal use only const VT_LPSTR: u32 = 0x001E; // 30 (0x1E) - ANSI string const VT_LPWSTR: u32 = 0x001F; // 31 (0x1F) - Wide string (UTF-16LE) const VT_FILETIME: u32 = 0x0040; // 64 (0x40) const VT_I2: u32 = 0x0002; // 2 (16-bit signed integer, used for codepage) const VT_I4: u32 = 0x0003; // 3 impl SummaryInformation { /// SummaryInformation을 바이트 배열에서 파싱합니다. / Parse SummaryInformation from byte array. /// /// # Arguments /// * `data` - \005HwpSummaryInformation 스트림의 원시 바이트 데이터 / Raw byte data of \005HwpSummaryInformation stream /// /// # Returns /// 파싱된 SummaryInformation 구조체 / Parsed SummaryInformation structure /// /// # Note /// MSDN Property Set 형식을 파싱합니다. /// Parses MSDN Property Set format. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.is_empty() { return Ok(SummaryInformation::default()); } let mut result = SummaryInformation::default(); // MSDN Property Set 형식 파싱 / Parse MSDN Property Set format // PropertySetStreamHeader 구조: // - ByteOrder (UINT16, 2 bytes) // - Version (UINT16, 2 bytes) // - SystemIdentifier (UINT32, 4 bytes) - pyhwp 참고 // - CLSID (16 bytes) // - propsetDescList (N_ARRAY, 가변 길이) // - 각 PropertySetDesc: FMTID (16 bytes) + Offset (4 bytes) = 20 bytes // - N_ARRAY는 먼저 개수(UINT32, 4 bytes)를 읽고, 그 다음 항목들을 읽음 if data.len() < 24 { return Err(HwpError::insufficient_data("Property Set header", 24, data.len())); } let mut offset = 0; // Byte order (2 bytes): 0xFEFF (little-endian) or 0xFFFE (big-endian) // MSDN Property Set 형식에서는 두 가지 모두 지원 // MSDN Property Set format supports both // Note: Byte order field is stored as raw bytes, not in a specific endianness // 주의: Byte order 필드는 raw 바이트로 저장되며, 특정 엔디언으로 저장되지 않음 // 0xFEFF (stored as [0xFE, 0xFF]) means little-endian // 0xFEFF ([0xFE, 0xFF]로 저장)는 little-endian을 의미 // 0xFFFE (stored as [0xFF, 0xFE]) means big-endian // 0xFFFE ([0xFF, 0xFE]로 저장)는 big-endian을 의미 let byte_order_bytes = [data[offset], data[offset + 1]]; // Read as big-endian to get the actual BOM value // 실제 BOM 값을 얻기 위해 big-endian으로 읽기 let byte_order = u16::from_be_bytes(byte_order_bytes); let is_big_endian = byte_order == 0xFFFE; if byte_order != 0xFEFF && byte_order != 0xFFFE { return Err(HwpError::UnexpectedValue { field: "Property Set byte order".to_string(), expected: "0xFEFF or 0xFFFE".to_string(), found: format!("0x{:04X}", byte_order), }); } offset += 2; // Version (2 bytes): Usually 0x0000 offset += 2; // SystemIdentifier (4 bytes): UINT32 (pyhwp 참고) // 실제 데이터를 보면 [5, 1, 2, 0]이 SystemIdentifier인 것 같습니다 // Looking at actual data, [5, 1, 2, 0] seems to be SystemIdentifier offset += 4; // CLSID (16 bytes): GUID, skip offset += 16; // propsetDescList: N_ARRAY이므로 먼저 개수 읽기 // propsetDescList: N_ARRAY, so read count first // N_ARRAY는 counttype (UINT32)로 개수를 읽습니다 // N_ARRAY reads count using counttype (UINT32) if offset + 4 > data.len() { return Err(HwpError::insufficient_data( "propsetDescList count", 4, data.len() - offset, )); } let num_property_sets = if is_big_endian { UINT32::from_be_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]) } else { UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]) }; offset += 4; if num_property_sets == 0 { return Ok(result); } // 첫 번째 PropertySetDesc 읽기 (일반적으로 하나만 있음) // Read first PropertySetDesc (usually only one) // 각 PropertySetDesc는 FMTID (16 bytes) + Offset (4 bytes) = 20 bytes // Each PropertySetDesc is FMTID (16 bytes) + Offset (4 bytes) = 20 bytes if offset + 20 > data.len() { return Err(HwpError::InsufficientData { field: "PropertySetDesc".to_string(), expected: offset + 20, actual: data.len(), }); } // FMTID (16 bytes) 건너뛰기 / Skip FMTID (16 bytes) offset += 16; // 첫 번째 PropertySetDesc의 offset 읽기 // Read offset of first PropertySetDesc // PropertySetDesc 구조: FMTID (16 bytes) + Offset (4 bytes) // PropertySetDesc structure: FMTID (16 bytes) + Offset (4 bytes) if offset + 4 > data.len() { return Err(HwpError::insufficient_data( "PropertySetDesc offset", 4, data.len() - offset, )); } // PropertySetDesc의 offset은 byte order에 따라 읽어야 함 // PropertySetDesc offset should be read according to byte order // 실제 데이터를 보면 offset 44에서 [48, 0, 0, 0] = 0x00000030 = 48 (little-endian) // Looking at actual data, at offset 44 we have [48, 0, 0, 0] = 0x00000030 = 48 (little-endian) let property_set_offset = if is_big_endian { UINT32::from_be_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]) as usize } else { UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]) as usize }; let property_set_start = property_set_offset; if property_set_start >= data.len() { return Err(HwpError::UnexpectedValue { field: format!("Property Set offset (start={})", property_set_start), expected: format!("< {}", data.len()), found: property_set_start.to_string(), }); } // Property Set Header: Size (4) + NumProperties (4) + Property entries if property_set_start + 8 > data.len() { return Err(HwpError::insufficient_data( "Property Set header", 8, data.len() - property_set_start, )); } // Size (4 bytes): Size of property set (from current offset to end of property set) let _property_set_size = if is_big_endian { UINT32::from_be_bytes([ data[property_set_start], data[property_set_start + 1], data[property_set_start + 2], data[property_set_start + 3], ]) as usize } else { UINT32::from_le_bytes([ data[property_set_start], data[property_set_start + 1], data[property_set_start + 2], data[property_set_start + 3], ]) as usize }; let mut offset = property_set_start + 4; // NumProperties (4 bytes): Number of properties let num_properties = if is_big_endian { UINT32::from_be_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]) } else { UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]) }; offset += 4; // Property entries: Each entry is Property ID (4) + Offset (4) = 8 bytes let property_entries_start = offset; let property_entries_size = (num_properties as usize) * 8; if offset + property_entries_size > data.len() { return Err(HwpError::InsufficientData { field: "property entries".to_string(), expected: offset + property_entries_size, actual: data.len(), }); } // Parse properties: find codepage first, then parse all properties // Property 파싱: 먼저 codepage를 찾고, 그 다음 모든 property 파싱 let mut codepage: u16 = 0xFFFF; // Default: invalid codepage for i in 0..num_properties { let entry_offset = property_entries_start + (i as usize * 8); // Property ID (4 bytes) let property_id = if is_big_endian { UINT32::from_be_bytes([ data[entry_offset], data[entry_offset + 1], data[entry_offset + 2], data[entry_offset + 3], ]) } else { UINT32::from_le_bytes([ data[entry_offset], data[entry_offset + 1], data[entry_offset + 2], data[entry_offset + 3], ]) }; // Offset (4 bytes): Offset from Property Set start (Size field) let value_offset = if is_big_endian { UINT32::from_be_bytes([ data[entry_offset + 4], data[entry_offset + 5], data[entry_offset + 6], data[entry_offset + 7], ]) as usize } else { UINT32::from_le_bytes([ data[entry_offset + 4], data[entry_offset + 5], data[entry_offset + 6], data[entry_offset + 7], ]) as usize }; let value_data_offset = property_set_start + value_offset; if value_data_offset >= data.len() { continue; } // Find codepage first if property_id == property_ids::PID_CODEPAGE { if let Ok(cp) = Self::parse_vt_i2(&data[value_data_offset..], is_big_endian) { codepage = cp as u16; } continue; } // Parse property value match property_id { property_ids::PIDSI_TITLE => { result.title = Self::parse_vt_lpstr(&data[value_data_offset..], is_big_endian, codepage) .ok(); } property_ids::PIDSI_SUBJECT => { result.subject = Self::parse_vt_lpstr(&data[value_data_offset..], is_big_endian, codepage) .ok(); } property_ids::PIDSI_AUTHOR => { result.author = Self::parse_vt_lpstr(&data[value_data_offset..], is_big_endian, codepage) .ok(); } property_ids::PIDSI_KEYWORDS => { result.keywords = Self::parse_vt_lpstr(&data[value_data_offset..], is_big_endian, codepage) .ok(); } property_ids::PIDSI_COMMENTS => { result.comments = Self::parse_vt_lpstr(&data[value_data_offset..], is_big_endian, codepage) .ok(); } property_ids::PIDSI_LASTAUTHOR => { result.last_saved_by = Self::parse_vt_lpstr(&data[value_data_offset..], is_big_endian, codepage) .ok(); } property_ids::PIDSI_REVNUMBER => { result.revision_number = Self::parse_vt_lpstr(&data[value_data_offset..], is_big_endian, codepage) .ok(); } property_ids::PIDSI_LASTPRINTED => { result.last_printed = Self::parse_vt_filetime(&data[value_data_offset..], is_big_endian) .ok() .map(|ft| ft.to_utc9_string()); } property_ids::PIDSI_CREATE_DTM => { result.create_time = Self::parse_vt_filetime(&data[value_data_offset..], is_big_endian) .ok() .map(|ft| ft.to_utc9_string()); } property_ids::PIDSI_LASTSAVE_DTM => { result.last_saved_time = Self::parse_vt_filetime(&data[value_data_offset..], is_big_endian) .ok() .map(|ft| ft.to_utc9_string()); } property_ids::PIDSI_PAGECOUNT => { result.page_count = Self::parse_vt_i4(&data[value_data_offset..], is_big_endian).ok(); } property_ids::HWPPIDSI_DATE_STR => { result.date_string = Self::parse_vt_lpstr(&data[value_data_offset..], is_big_endian, codepage) .ok(); } property_ids::HWPPIDSI_PARACOUNT => { result.para_count = Self::parse_vt_i4(&data[value_data_offset..], is_big_endian).ok(); } _ => { // Unknown property ID, skip } } } Ok(result) } /// VT_I2 파싱 (16-bit signed integer, codepage에 사용) / Parse VT_I2 (16-bit signed integer, used for codepage) /// Format: VT type (4 bytes) + Value (2 bytes) fn parse_vt_i2(data: &[u8], is_big_endian: bool) -> Result<i16, HwpError> { if data.len() < 6 { return Err(HwpError::insufficient_data("VT_I2", 6, data.len())); } // VT type (4 bytes): Should be VT_I2 (0x0002) let vt_type = if is_big_endian { UINT32::from_be_bytes([data[0], data[1], data[2], data[3]]) } else { UINT32::from_le_bytes([data[0], data[1], data[2], data[3]]) }; if vt_type != VT_I2 { return Err(HwpError::UnexpectedValue { field: "VT_I2 type".to_string(), expected: format!("0x{:08X}", VT_I2), found: format!("0x{:08X}", vt_type), }); } // Value (2 bytes): Signed 16-bit integer let value = if is_big_endian { i16::from_be_bytes([data[4], data[5]]) } else { i16::from_le_bytes([data[4], data[5]]) }; Ok(value) } /// VT_LPSTR 또는 VT_LPWSTR 파싱 (문자열) / Parse VT_LPSTR or VT_LPWSTR (string) /// Format: VT type (4 bytes) + Length (4 bytes) + String (null-terminated) /// codepage에 따라 적절한 인코딩으로 디코딩 / Decode using appropriate encoding based on codepage fn parse_vt_lpstr(data: &[u8], is_big_endian: bool, codepage: u16) -> Result<String, HwpError> { if data.len() < 8 { return Err(HwpError::insufficient_data("VT_LPSTR/VT_LPWSTR", 8, data.len())); } // VT type (4 bytes): Should be VT_LPSTR (0x001E) or VT_LPWSTR (0x001F) let vt_type = if is_big_endian { UINT32::from_be_bytes([data[0], data[1], data[2], data[3]]) } else { UINT32::from_le_bytes([data[0], data[1], data[2], data[3]]) }; // VT_LPWSTR (wide string) 처리 if vt_type == VT_LPWSTR { return Self::parse_vt_lpwstr(data, is_big_endian); } if vt_type != VT_LPSTR { return Err(HwpError::UnexpectedValue { field: "VT_LPSTR/VT_LPWSTR type".to_string(), expected: format!("0x{:08X} or 0x{:08X}", VT_LPSTR, VT_LPWSTR), found: format!("0x{:08X}", vt_type), }); } // Length (4 bytes): String length in bytes (including null terminator) // hwplib의 CodePageString처럼 size만큼 읽음 let size = if is_big_endian { UINT32::from_be_bytes([data[4], data[5], data[6], data[7]]) as usize } else { UINT32::from_le_bytes([data[4], data[5], data[6], data[7]]) as usize }; if data.len() < 8 + size { return Err(HwpError::InsufficientData { field: "VT_LPSTR string".to_string(), expected: 8 + size, actual: data.len(), }); } // String data: size만큼 읽음 (hwplib의 CodePageString처럼) let string_data = &data[8..8 + size]; // Decode string based on codepage // codepage에 따라 적절한 인코딩으로 디코딩 Self::decode_string_by_codepage(string_data, codepage) .map_err(|e| HwpError::EncodingError { reason: format!( "Failed to decode VT_LPSTR string with codepage {}: {}", codepage, e ), }) } /// VT_FILETIME 파싱 (날짜/시간) / Parse VT_FILETIME (date/time) /// Format: VT type (4 bytes) + FILETIME (8 bytes: low 4 bytes + high 4 bytes) fn parse_vt_filetime(data: &[u8], is_big_endian: bool) -> Result<FileTime, HwpError> { if data.len() < 12 { return Err(HwpError::insufficient_data("VT_FILETIME", 12, data.len())); } // VT type (4 bytes): Should be VT_FILETIME (0x0040) let vt_type = if is_big_endian { UINT32::from_be_bytes([data[0], data[1], data[2], data[3]]) } else { UINT32::from_le_bytes([data[0], data[1], data[2], data[3]]) }; if vt_type != VT_FILETIME { return Err(HwpError::UnexpectedValue { field: "VT_FILETIME type".to_string(), expected: format!("0x{:08X}", VT_FILETIME), found: format!("0x{:08X}", vt_type), }); } // FILETIME: Low 32 bits (4 bytes) + High 32 bits (4 bytes) let low = if is_big_endian { UINT32::from_be_bytes([data[4], data[5], data[6], data[7]]) } else { UINT32::from_le_bytes([data[4], data[5], data[6], data[7]]) }; let high = if is_big_endian { UINT32::from_be_bytes([data[8], data[9], data[10], data[11]]) } else { UINT32::from_le_bytes([data[8], data[9], data[10], data[11]]) }; Ok(FileTime { low, high }) } /// VT_LPWSTR 파싱 (Wide string, UTF-16LE) / Parse VT_LPWSTR (Wide string, UTF-16LE) /// Format: VT type (4 bytes) + Length (4 bytes, character count) + String (UTF-16LE, null-terminated) /// hwplib의 UnicodeString 구현 참고 fn parse_vt_lpwstr(data: &[u8], is_big_endian: bool) -> Result<String, HwpError> { if data.len() < 8 { return Err(HwpError::insufficient_data("VT_LPWSTR", 8, data.len())); } // VT type (4 bytes): Should be VT_LPWSTR (0x001F) let vt_type = if is_big_endian { UINT32::from_be_bytes([data[0], data[1], data[2], data[3]]) } else { UINT32::from_le_bytes([data[0], data[1], data[2], data[3]]) }; if vt_type != VT_LPWSTR { return Err(HwpError::UnexpectedValue { field: "VT_LPWSTR type".to_string(), expected: format!("0x{:08X}", VT_LPWSTR), found: format!("0x{:08X}", vt_type), }); } // Length (4 bytes): Character count (not byte count) // hwplib의 UnicodeString처럼 character count를 읽음 let char_count = if is_big_endian { UINT32::from_be_bytes([data[4], data[5], data[6], data[7]]) as usize } else { UINT32::from_le_bytes([data[4], data[5], data[6], data[7]]) as usize }; if char_count == 0 { return Ok(String::new()); } // UTF-16LE: 각 character는 2 bytes let byte_count = char_count * 2; if data.len() < 8 + byte_count { return Err(HwpError::InsufficientData { field: "VT_LPWSTR string".to_string(), expected: 8 + byte_count, actual: data.len(), }); } // String data: UTF-16LE bytes // hwplib의 UnicodeString처럼 length * 2 바이트를 읽음 let string_bytes = &data[8..8 + byte_count]; // UTF-16LE 디코딩 (hwplib의 StringUtil.getFromUnicodeLE처럼) let mut chars = Vec::new(); for i in (0..string_bytes.len()).step_by(2) { if i + 1 < string_bytes.len() { let code_point = u16::from_le_bytes([string_bytes[i], string_bytes[i + 1]]); if code_point == 0 { break; // null terminator } if let Some(ch) = char::from_u32(code_point as u32) { chars.push(ch); } } } Ok(chars.into_iter().collect()) } /// Codepage에 따라 문자열 디코딩 / Decode string based on codepage /// hwplib의 CodePageString.getJavaValue() 로직 참고 fn decode_string_by_codepage(data: &[u8], codepage: u16) -> Result<String, HwpError> { use encoding_rs::*; if data.is_empty() { return Ok(String::new()); } // Codepage 상수 (hwplib 참고) const CP_UTF16: u16 = 1200; const CP_UTF16_BE: u16 = 1201; const CP_UTF8: u16 = 65001; const CP_MS949: u16 = 949; const CP_WINDOWS_1252: u16 = 1252; // hwplib처럼 codepage가 -1 (0xFFFF)이면 기본 인코딩 사용 let result = if codepage == 0xFFFF { // Default: try UTF-8, fallback to Windows-1252 String::from_utf8(data.to_vec()) .unwrap_or_else(|_| WINDOWS_1252.decode(data).0.to_string()) } else { match codepage { CP_UTF16 => { let mut chars = Vec::new(); for i in (0..data.len()).step_by(2) { if i + 1 < data.len() { let code_point = u16::from_le_bytes([data[i], data[i + 1]]); if let Some(ch) = char::from_u32(code_point as u32) { if ch != '\0' { chars.push(ch); } } } } chars.into_iter().collect() } CP_UTF16_BE => { let mut chars = Vec::new(); for i in (0..data.len()).step_by(2) { if i + 1 < data.len() { let code_point = u16::from_be_bytes([data[i], data[i + 1]]); if let Some(ch) = char::from_u32(code_point as u32) { if ch != '\0' { chars.push(ch); } } } } chars.into_iter().collect() } CP_UTF8 => String::from_utf8(data.to_vec()) .map_err(|e| HwpError::EncodingError { reason: format!("UTF-8 decode error: {}", e), })?, CP_MS949 => EUC_KR.decode(data).0.to_string(), CP_WINDOWS_1252 => WINDOWS_1252.decode(data).0.to_string(), _ => { // Unknown codepage: try UTF-8, fallback to Windows-1252 String::from_utf8(data.to_vec()) .unwrap_or_else(|_| WINDOWS_1252.decode(data).0.to_string()) } } }; // Remove null terminator (hwplib의 CodePageString.getJavaValue처럼) // hwplib는 null terminator를 찾아서 substring(0, terminator)를 반환 let terminator = result.find('\0'); if let Some(pos) = terminator { Ok(result[..pos].to_string()) } else { Ok(result) } } /// VT_I4 파싱 (32-bit signed integer) / Parse VT_I4 (32-bit signed integer) /// Format: VT type (4 bytes) + Value (4 bytes) fn parse_vt_i4(data: &[u8], is_big_endian: bool) -> Result<INT32, HwpError> { if data.len() < 8 { return Err(HwpError::insufficient_data("VT_I4", 8, data.len())); } // VT type (4 bytes): Should be VT_I4 (0x0003) let vt_type = if is_big_endian { UINT32::from_be_bytes([data[0], data[1], data[2], data[3]]) } else { UINT32::from_le_bytes([data[0], data[1], data[2], data[3]]) }; if vt_type != VT_I4 { return Err(HwpError::UnexpectedValue { field: "VT_I4 type".to_string(), expected: format!("0x{:08X}", VT_I4), found: format!("0x{:08X}", vt_type), }); } // Value (4 bytes): Signed 32-bit integer let value = if is_big_endian {

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

true

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/constants.rs

crates/hwp-core/src/document/constants.rs

/// 공통 태그 상수 정의 / Common tag constants definition /// /// HWPTAG_BEGIN = 0x10 (한글 내부 사용을 위해 예약된 영역의 시작) / HWPTAG_BEGIN = 0x10 (start of reserved area for HWP internal use) /// 데이터 레코드 시작 값 / Data record start value pub const HWPTAG_BEGIN: u16 = 0x10;

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/scripts/script_version.rs

crates/hwp-core/src/document/scripts/script_version.rs

/// ScriptVersion 구조체 / ScriptVersion structure /// /// 스펙 문서 매핑: 표 8 - 스크립트 버전 / Spec mapping: Table 8 - Script version use crate::error::HwpError; use crate::types::DWORD; use serde::{Deserialize, Serialize}; /// 스크립트 버전 / Script version #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ScriptVersion { /// 스크립트 버전 HIGH / Script version HIGH pub high: DWORD, /// 스크립트 버전 LOW / Script version LOW pub low: DWORD, } impl ScriptVersion { /// ScriptVersion을 바이트 배열에서 파싱합니다. / Parse ScriptVersion from byte array. /// /// # Arguments /// * `data` - JScriptVersion 스트림의 원시 바이트 데이터 / Raw byte data of JScriptVersion stream /// /// # Returns /// 파싱된 ScriptVersion 구조체 / Parsed ScriptVersion structure /// /// # Note /// 스펙 문서 표 8에 따르면 스크립트 버전은 8바이트입니다: /// - DWORD (4 bytes): 스크립트 버전 HIGH /// - DWORD (4 bytes): 스크립트 버전 LOW /// According to spec Table 8, script version is 8 bytes: /// - DWORD (4 bytes): Script version HIGH /// - DWORD (4 bytes): Script version LOW pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 8 { return Err(HwpError::insufficient_data("ScriptVersion", 8, data.len())); } // DWORD 스크립트 버전 HIGH (4 bytes) / Script version HIGH (4 bytes) let high = DWORD::from_le_bytes([data[0], data[1], data[2], data[3]]); // DWORD 스크립트 버전 LOW (4 bytes) / Script version LOW (4 bytes) let low = DWORD::from_le_bytes([data[4], data[5], data[6], data[7]]); Ok(ScriptVersion { high, low }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/scripts/mod.rs

crates/hwp-core/src/document/scripts/mod.rs

/// Scripts parsing module /// /// This module handles parsing of HWP Scripts storage. /// /// 스펙 문서 매핑: 3.2.9 - 스크립트 / Spec mapping: 3.2.9 - Scripts mod script; mod script_version; pub use script::Script; pub use script_version::ScriptVersion; use crate::cfb::CfbParser; use crate::error::HwpError; use serde::{Deserialize, Serialize}; /// Scripts structure /// 스크립트 구조 #[derive(Debug, Clone, Default, Serialize, Deserialize)] pub struct Scripts { /// Script version (from JScriptVersion stream) / 스크립트 버전 (JScriptVersion 스트림) pub version: Option<ScriptVersion>, /// Default script (from DefaultJScript stream) / 기본 스크립트 (DefaultJScript 스트림) pub default_script: Option<Script>, } impl Scripts { /// Parse Scripts storage from CFB structure /// CFB 구조에서 Scripts 스토리지를 파싱합니다. /// /// # Arguments /// * `cfb` - CompoundFile structure (mutable reference required) / CompoundFile 구조체 (가변 참조 필요) /// /// # Returns /// Parsed Scripts structure / 파싱된 Scripts 구조체 /// /// # Note /// 스펙 문서 3.2.9에 따르면 Scripts 스토리지에는 다음 스트림이 포함됩니다: /// - JScriptVersion: 스크립트 버전 (표 8) /// - DefaultJScript: 스크립트 내용 (표 9) /// According to spec 3.2.9, Scripts storage contains the following streams: /// - JScriptVersion: Script version (Table 8) /// - DefaultJScript: Script content (Table 9) pub fn parse(cfb: &mut cfb::CompoundFile<std::io::Cursor<&[u8]>>) -> Result<Self, HwpError> { let mut scripts = Scripts::default(); // Parse JScriptVersion stream // JScriptVersion 스트림 파싱 / Parse JScriptVersion stream // 스펙 문서 표 8: 스크립트 버전은 8바이트 (DWORD HIGH + DWORD LOW) // Spec Table 8: Script version is 8 bytes (DWORD HIGH + DWORD LOW) if let Ok(version_data) = CfbParser::read_nested_stream(cfb, "Scripts", "JScriptVersion") { match ScriptVersion::parse(&version_data) { Ok(version) => { scripts.version = Some(version); } Err(e) => { #[cfg(debug_assertions)] eprintln!("Warning: Failed to parse JScriptVersion stream: {}", e); } } } // Parse DefaultJScript stream // DefaultJScript 스트림 파싱 / Parse DefaultJScript stream // 스펙 문서 표 9: 스크립트 내용은 가변 길이 // Spec Table 9: Script content is variable length if let Ok(script_data) = CfbParser::read_nested_stream(cfb, "Scripts", "DefaultJScript") { match Script::parse(&script_data) { Ok(default_script) => { scripts.default_script = Some(default_script); } Err(e) => { #[cfg(debug_assertions)] eprintln!("Warning: Failed to parse DefaultJScript stream: {}", e); } } } Ok(scripts) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/scripts/script.rs

crates/hwp-core/src/document/scripts/script.rs

/// Script 구조체 / Script structure /// /// 스펙 문서 매핑: 표 9 - 스크립트 / Spec mapping: Table 9 - Script use crate::error::HwpError; use crate::types::{decode_utf16le, DWORD}; use serde::{Deserialize, Serialize}; /// 스크립트 / Script #[derive(Debug, Clone, Serialize, Deserialize)] pub struct Script { /// 스크립트 헤더 / Script header pub header: String, /// 스크립트 소스 / Script source pub source: String, /// 스크립트 Pre 소스 / Script pre source pub pre_source: String, /// 스크립트 Post 소스 / Script post source pub post_source: String, } impl Script { /// Script를 바이트 배열에서 파싱합니다. / Parse Script from byte array. /// /// # Arguments /// * `data` - DefaultJScript 스트림의 원시 바이트 데이터 / Raw byte data of DefaultJScript stream /// /// # Returns /// 파싱된 Script 구조체 / Parsed Script structure /// /// # Note /// 스펙 문서 표 9에 따르면 스크립트는 다음 구조를 가집니다: /// - DWORD (4 bytes): 스크립트 헤더 길이 (len1) /// - WCHAR array[len1] (2×len1 bytes): 스크립트 헤더 /// - DWORD (4 bytes): 스크립트 소스 길이 (len2) /// - WCHAR array[len2] (2×len2 bytes): 스크립트 소스 /// - DWORD (4 bytes): 스크립트 Pre 소스 길이 (len3) /// - WCHAR array[len3] (2×len3 bytes): 스크립트 Pre 소스 /// - DWORD (4 bytes): 스크립트 Post 소스 길이 (len4) /// - WCHAR array[len4] (2×len4 bytes): 스크립트 Post 소스 /// - DWORD (4 bytes): 스크립트 end flag (-1) /// According to spec Table 9, script has the following structure: /// - DWORD (4 bytes): Script header length (len1) /// - WCHAR array[len1] (2×len1 bytes): Script header /// - DWORD (4 bytes): Script source length (len2) /// - WCHAR array[len2] (2×len2 bytes): Script source /// - DWORD (4 bytes): Script pre source length (len3) /// - WCHAR array[len3] (2×len3 bytes): Script pre source /// - DWORD (4 bytes): Script post source length (len4) /// - WCHAR array[len4] (2×len4 bytes): Script post source /// - DWORD (4 bytes): Script end flag (-1) pub fn parse(data: &[u8]) -> Result<Self, HwpError> { let mut offset = 0; // 최소 20바이트 필요 (4개의 DWORD 길이 필드 + end flag) / Need at least 20 bytes (4 DWORD length fields + end flag) if data.len() < 20 { return Err(HwpError::insufficient_data("Script", 20, data.len())); } // DWORD 스크립트 헤더 길이 (4 bytes) / Script header length (4 bytes) let header_len = DWORD::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]) as usize; offset += 4; // WCHAR array[len1] 스크립트 헤더 (2×len1 bytes) / Script header (2×len1 bytes) let header = if header_len > 0 { let header_bytes_len = header_len.saturating_mul(2); if offset + header_bytes_len <= data.len() { let header_bytes = &data[offset..offset + header_bytes_len]; decode_utf16le(header_bytes).unwrap_or_default() } else { String::new() } } else { String::new() }; offset = offset.saturating_add(header_len.saturating_mul(2)); // DWORD 스크립트 소스 길이 (4 bytes) / Script source length (4 bytes) if offset + 4 > data.len() { return Err(HwpError::insufficient_data( "Script source length", 4, data.len().saturating_sub(offset), )); } let source_len = DWORD::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]) as usize; offset += 4; // WCHAR array[len2] 스크립트 소스 (2×len2 bytes) / Script source (2×len2 bytes) let source = if source_len > 0 { let source_bytes_len = source_len.saturating_mul(2); if offset + source_bytes_len <= data.len() { let source_bytes = &data[offset..offset + source_bytes_len]; decode_utf16le(source_bytes).unwrap_or_default() } else { String::new() } } else { String::new() }; offset = offset.saturating_add(source_len.saturating_mul(2)); // DWORD 스크립트 Pre 소스 길이 (4 bytes) / Script pre source length (4 bytes) if offset + 4 > data.len() { return Err(HwpError::insufficient_data( "Script pre source length", 4, data.len().saturating_sub(offset), )); } let pre_source_len = DWORD::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]) as usize; offset += 4; // WCHAR array[len3] 스크립트 Pre 소스 (2×len3 bytes) / Script pre source (2×len3 bytes) let pre_source = if pre_source_len > 0 { let pre_source_bytes_len = pre_source_len.saturating_mul(2); if offset + pre_source_bytes_len <= data.len() { let pre_source_bytes = &data[offset..offset + pre_source_bytes_len]; decode_utf16le(pre_source_bytes).unwrap_or_default() } else { String::new() } } else { String::new() }; offset = offset.saturating_add(pre_source_len.saturating_mul(2)); // DWORD 스크립트 Post 소스 길이 (4 bytes) / Script post source length (4 bytes) if offset + 4 > data.len() { return Err(HwpError::insufficient_data( "Script post source length", 4, data.len().saturating_sub(offset), )); } let post_source_len = DWORD::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]) as usize; offset += 4; // WCHAR array[len4] 스크립트 Post 소스 (2×len4 bytes) / Script post source (2×len4 bytes) let post_source = if post_source_len > 0 { let post_source_bytes_len = post_source_len.saturating_mul(2); if offset + post_source_bytes_len <= data.len() { let post_source_bytes = &data[offset..offset + post_source_bytes_len]; decode_utf16le(post_source_bytes).unwrap_or_default() } else { String::new() } } else { String::new() }; offset = offset.saturating_add(post_source_len.saturating_mul(2)); // DWORD 스크립트 end flag (-1) (4 bytes) / Script end flag (-1) (4 bytes) // 검증 목적으로 읽지만 사용하지 않음 / Read for validation but not used if offset + 4 <= data.len() { let end_flag = DWORD::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); if end_flag != 0xFFFFFFFF { #[cfg(debug_assertions)] eprintln!( "Warning: Script end flag is not -1 (0xFFFFFFFF), got 0x{:08X}", end_flag ); } } Ok(Script { header, source, pre_source, post_source, }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/track_change.rs

crates/hwp-core/src/document/docinfo/track_change.rs

/// TrackChange 구조체 / TrackChange structure /// /// 스펙 문서 매핑: 표 4 - 변경 추적 정보 / Spec mapping: Table 4 - Track change information /// 상세 구조는 스펙 문서에 명시되지 않음 / Detailed structure not specified in spec use crate::error::HwpError; use serde::{Deserialize, Serialize}; /// 변경 추적 정보 / Track change information #[derive(Debug, Clone, Serialize, Deserialize)] pub struct TrackChange { /// Raw data (1032바이트) / Raw data (1032 bytes) #[serde(skip)] pub raw_data: Vec<u8>, } impl TrackChange { /// TrackChange를 바이트 배열에서 파싱합니다. / Parse TrackChange from byte array. /// /// # Arguments /// * `data` - TrackChange 데이터 (1032바이트) / TrackChange data (1032 bytes) /// /// # Returns /// 파싱된 TrackChange 구조체 / Parsed TrackChange structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 1032 { return Err(HwpError::insufficient_data("TrackChange", 1032, data.len())); } Ok(TrackChange { raw_data: data[0..1032.min(data.len())].to_vec(), }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/track_change_author.rs

crates/hwp-core/src/document/docinfo/track_change_author.rs

/// TrackChangeAuthor 구조체 / TrackChangeAuthor structure /// /// 스펙 문서 매핑: 표 4 - 변경 추적 작성자 / Spec mapping: Table 4 - Track change author /// 상세 구조는 스펙 문서에 명시되지 않음 / Detailed structure not specified in spec use crate::error::HwpError; use serde::{Deserialize, Serialize}; /// 변경 추적 작성자 / Track change author #[derive(Debug, Clone, Serialize, Deserialize)] pub struct TrackChangeAuthor { /// Raw data (가변) / Raw data (variable) #[serde(skip)] pub raw_data: Vec<u8>, } impl TrackChangeAuthor { /// TrackChangeAuthor를 바이트 배열에서 파싱합니다. / Parse TrackChangeAuthor from byte array. /// /// # Arguments /// * `data` - TrackChangeAuthor 데이터 (가변) / TrackChangeAuthor data (variable) /// /// # Returns /// 파싱된 TrackChangeAuthor 구조체 / Parsed TrackChangeAuthor structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { Ok(TrackChangeAuthor { raw_data: data.to_vec(), }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/id_mappings.rs

crates/hwp-core/src/document/docinfo/id_mappings.rs

/// ID Mappings 구조체 / ID Mappings structure /// /// 스펙 문서 매핑: 표 15 - 아이디 매핑 헤더 / Spec mapping: Table 15 - ID mappings header /// Tag ID: HWPTAG_ID_MAPPINGS /// 전체 길이: 72 바이트 (18개 INT32) / Total length: 72 bytes (18 INT32 values) use crate::error::HwpError; use crate::types::INT32; use serde::{Deserialize, Serialize}; /// ID Mappings 구조체 / ID Mappings structure /// /// 스펙 문서 표 15에 따르면, 각 필드는 해당 타입의 레코드 개수를 나타냅니다. /// According to spec document Table 15, each field represents the count of records of the corresponding type. /// /// 스펙 문서 매핑: 표 15 - 아이디 매핑 헤더, 표 16 - 아이디 매핑 개수 인덱스 /// Spec mapping: Table 15 - ID mappings header, Table 16 - ID mapping count indices #[derive(Debug, Clone, Serialize, Deserialize)] pub struct IdMappings { /// 바이너리 데이터 개수 (HWPTAG_BIN_DATA 레코드 개수, 표 16 인덱스 0) / Binary data count (HWPTAG_BIN_DATA record count, Table 16 index 0) pub binary_data: INT32, /// 한글 글꼴 개수 (HWPTAG_FACE_NAME 레코드 개수, 표 16 인덱스 1) / Korean font count (HWPTAG_FACE_NAME record count, Table 16 index 1) pub font_korean: INT32, /// 영어 글꼴 개수 (HWPTAG_FACE_NAME 레코드 개수, 표 16 인덱스 2) / English font count (HWPTAG_FACE_NAME record count, Table 16 index 2) pub font_english: INT32, /// 한자 글꼴 개수 (HWPTAG_FACE_NAME 레코드 개수, 표 16 인덱스 3) / Chinese font count (HWPTAG_FACE_NAME record count, Table 16 index 3) pub font_chinese: INT32, /// 일어 글꼴 개수 (HWPTAG_FACE_NAME 레코드 개수, 표 16 인덱스 4) / Japanese font count (HWPTAG_FACE_NAME record count, Table 16 index 4) pub font_japanese: INT32, /// 기타 글꼴 개수 (HWPTAG_FACE_NAME 레코드 개수, 표 16 인덱스 5) / Other font count (HWPTAG_FACE_NAME record count, Table 16 index 5) pub font_other: INT32, /// 기호 글꼴 개수 (HWPTAG_FACE_NAME 레코드 개수, 표 16 인덱스 6) / Symbol font count (HWPTAG_FACE_NAME record count, Table 16 index 6) pub font_symbol: INT32, /// 사용자 글꼴 개수 (HWPTAG_FACE_NAME 레코드 개수, 표 16 인덱스 7) / User font count (HWPTAG_FACE_NAME record count, Table 16 index 7) pub font_user: INT32, /// 테두리/배경 개수 (HWPTAG_BORDER_FILL 레코드 배열 크기, 표 16 인덱스 8) / Border/fill count (HWPTAG_BORDER_FILL record array size, Table 16 index 8) pub border_fill: INT32, /// 글자 모양 개수 (HWPTAG_CHAR_SHAPE 레코드 배열 크기, 표 16 인덱스 9) / Character shape count (HWPTAG_CHAR_SHAPE record array size, Table 16 index 9) pub char_shape: INT32, /// 탭 정의 개수 (HWPTAG_TAB_DEF 레코드 배열 크기, 표 16 인덱스 10) / Tab definition count (HWPTAG_TAB_DEF record array size, Table 16 index 10) pub tab_def: INT32, /// 문단 번호 개수 (HWPTAG_NUMBERING 레코드 배열 크기, 표 16 인덱스 11) / Paragraph numbering count (HWPTAG_NUMBERING record array size, Table 16 index 11) pub paragraph_numbering: INT32, /// 글머리표 개수 (HWPTAG_BULLET 레코드 배열 크기, 표 16 인덱스 12) / Bullet count (HWPTAG_BULLET record array size, Table 16 index 12) pub bullet: INT32, /// 문단 모양 개수 (HWPTAG_PARA_SHAPE 레코드 배열 크기, 표 16 인덱스 13) / Paragraph shape count (HWPTAG_PARA_SHAPE record array size, Table 16 index 13) pub paragraph_shape: INT32, /// 스타일 개수 (HWPTAG_STYLE 레코드 배열 크기, 표 16 인덱스 14) / Style count (HWPTAG_STYLE record array size, Table 16 index 14) pub style: INT32, /// 메모 모양 개수 (5.0.2.1 이상, 표 16 인덱스 15) / Memo shape count (5.0.2.1 and above, Table 16 index 15) pub memo_shape: Option<INT32>, /// 변경추적 개수 (5.0.3.2 이상, 표 16 인덱스 16) / Track change count (5.0.3.2 and above, Table 16 index 16) pub track_change: Option<INT32>, /// 변경추적 사용자 개수 (5.0.3.2 이상, 표 16 인덱스 17) / Track change author count (5.0.3.2 and above, Table 16 index 17) pub track_change_author: Option<INT32>, } impl IdMappings { /// IdMappings를 바이트 배열에서 파싱합니다. / Parse IdMappings from byte array. /// /// # Arguments /// * `data` - 최소 72바이트의 데이터 (18개 INT32) / At least 72 bytes of data (18 INT32 values) /// * `version` - FileHeader의 version (버전에 따라 필드 개수가 다를 수 있음) / FileHeader version (field count may vary by version) /// /// # Returns /// 파싱된 IdMappings 구조체 / Parsed IdMappings structure pub fn parse(data: &[u8], _version: u32) -> Result<Self, HwpError> { // 최소 60바이트 (15개 INT32) 필요 / Need at least 60 bytes (15 INT32 values) if data.len() < 60 { return Err(HwpError::insufficient_data("IdMappings", 60, data.len())); } let mut offset = 0; // INT32 배열 읽기 (각 4바이트) / Read INT32 array (4 bytes each) let read_int32 = |offset: &mut usize| -> INT32 { let value = INT32::from_le_bytes([ data[*offset], data[*offset + 1], data[*offset + 2], data[*offset + 3], ]); *offset += 4; value }; // 기본 15개 필드 (60바이트) / Basic 15 fields (60 bytes) let binary_data = read_int32(&mut offset); let font_korean = read_int32(&mut offset); let font_english = read_int32(&mut offset); let font_chinese = read_int32(&mut offset); let font_japanese = read_int32(&mut offset); let font_other = read_int32(&mut offset); let font_symbol = read_int32(&mut offset); let font_user = read_int32(&mut offset); let border_fill = read_int32(&mut offset); let char_shape = read_int32(&mut offset); let tab_def = read_int32(&mut offset); let paragraph_numbering = read_int32(&mut offset); let bullet = read_int32(&mut offset); let paragraph_shape = read_int32(&mut offset); let style = read_int32(&mut offset); // 버전에 따른 선택적 필드 / Optional fields based on version // 레거시 코드 기준: version >= 5017일 때 메모 모양 추가 / Legacy code: memo shape added when version >= 5017 // 스펙 문서: 5.0.2.1 이상 / Spec document: 5.0.2.1 and above // 데이터 크기로 판단: 64바이트 이상이면 메모 모양 필드 존재 / Determine by data size: memo shape field exists if 64 bytes or more let memo_shape = if data.len() >= 64 && offset + 4 <= data.len() { Some(read_int32(&mut offset)) } else { None }; // 변경추적: 레거시 코드 기준 version >= 5032 / Track change: legacy code version >= 5032 // 스펙 문서: 5.0.3.2 이상 / Spec document: 5.0.3.2 and above // 데이터 크기로 판단: 68바이트 이상이면 변경추적 필드 존재 / Determine by data size: track change field exists if 68 bytes or more let track_change = if data.len() >= 68 && offset + 4 <= data.len() { Some(read_int32(&mut offset)) } else { None }; // 변경추적 사용자: 레거시 코드 기준 version >= 5032 / Track change author: legacy code version >= 5032 // 데이터 크기로 판단: 72바이트 이상이면 변경추적 사용자 필드 존재 / Determine by data size: track change author field exists if 72 bytes or more let track_change_author = if data.len() >= 72 && offset + 4 <= data.len() { Some(read_int32(&mut offset)) } else { None }; Ok(IdMappings { binary_data, font_korean, font_english, font_chinese, font_japanese, font_other, font_symbol, font_user, border_fill, char_shape, tab_def, paragraph_numbering, bullet, paragraph_shape, style, memo_shape, track_change, track_change_author, }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/document_properties.rs

crates/hwp-core/src/document/docinfo/document_properties.rs

/// Document Properties 구조체 / Document Properties structure /// /// 스펙 문서 매핑: 표 14 - 문서 속성 / Spec mapping: Table 14 - Document properties /// Tag ID: HWPTAG_DOCUMENT_PROPERTIES /// 전체 길이: 26 바이트 / Total length: 26 bytes use crate::error::HwpError; use crate::types::{UINT16, UINT32}; use serde::{Deserialize, Serialize}; /// 문서 속성 구조체 / Document properties structure #[derive(Debug, Clone, Serialize, Deserialize)] pub struct DocumentProperties { /// 구역 개수 / Area count pub area_count: UINT16, /// 문서 내 각종 시작번호에 대한 정보 / Start number information pub start_number_info: UINT16, /// 페이지 시작 번호 / Page start number pub page_start_number: UINT16, /// 각주 시작 번호 / Footnote start number pub footnote_start_number: UINT16, /// 미주 시작 번호 / Endnote start number pub endnote_start_number: UINT16, /// 그림 시작 번호 / Image start number pub image_start_number: UINT16, /// 표 시작 번호 / Table start number pub table_start_number: UINT16, /// 수식 시작 번호 / Formula start number pub formula_start_number: UINT16, /// 문서 내 캐럿의 위치 정보 (리스트 아이디) / Caret position information in document (list ID) pub list_id: UINT32, /// 문단 아이디 / Paragraph ID pub paragraph_id: UINT32, /// 문단 내에서의 글자 단위 위치 / Character position within paragraph pub character_position: UINT32, } impl DocumentProperties { /// DocumentProperties를 바이트 배열에서 파싱합니다. / Parse DocumentProperties from byte array. /// /// # Arguments /// * `data` - 최소 26바이트의 데이터 / At least 26 bytes of data /// /// # Returns /// 파싱된 DocumentProperties 구조체 / Parsed DocumentProperties structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // 레거시 코드 기준으로 26바이트를 읽음 // Read 26 bytes based on legacy code if data.len() < 26 { return Err(HwpError::insufficient_data("DocumentProperties", 26, data.len())); } let mut offset = 0; // UINT16 구역 개수 / UINT16 area count let area_count = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT16 페이지 시작 번호 / UINT16 page start number // Note: 레거시 코드에서는 "문서 내 각종 시작번호에 대한 정보" 필드를 건너뛰고 바로 페이지 시작 번호를 읽음 // Note: Legacy code skips "start number information" field and reads page_start_number directly let page_start_number = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT16 각주 시작 번호 / UINT16 footnote start number let footnote_start_number = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT16 미주 시작 번호 / UINT16 endnote start number let endnote_start_number = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT16 그림 시작 번호 / UINT16 image start number let image_start_number = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT16 표 시작 번호 / UINT16 table start number let table_start_number = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT16 수식 시작 번호 / UINT16 formula start number let formula_start_number = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT32 문서 내 캐럿의 위치 정보 (리스트 아이디) / UINT32 caret position (list ID) let list_id = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // UINT32 문단 아이디 / UINT32 paragraph ID let paragraph_id = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // UINT32 문단 내에서의 글자 단위 위치 / UINT32 character position within paragraph let character_position = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); Ok(DocumentProperties { area_count, start_number_info: 0, // 레거시 코드에서는 이 필드를 건너뜀 / This field is skipped in legacy code page_start_number, footnote_start_number, endnote_start_number, image_start_number, table_start_number, formula_start_number, list_id, paragraph_id, character_position, }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/tab_def.rs

crates/hwp-core/src/document/docinfo/tab_def.rs

/// Tab Definition 구조체 / Tab Definition structure /// /// 스펙 문서 매핑: 표 36 - 탭 정의 / Spec mapping: Table 36 - Tab definition /// Tag ID: HWPTAG_TAB_DEF /// 전체 길이: 가변 (8 + 8×count 바이트) / Total length: variable (8 + 8×count bytes) use crate::error::HwpError; use crate::types::{HWPUNIT, INT16, UINT32, UINT8}; use serde::{Deserialize, Serialize}; /// 탭 종류 / Tab type #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum TabType { /// 왼쪽 / Left Left = 0, /// 오른쪽 / Right Right = 1, /// 가운데 / Center Center = 2, /// 소수점 / Decimal Decimal = 3, } impl TabType { /// UINT8 값에서 TabType 생성 / Create TabType from UINT8 value fn from_byte(value: UINT8) -> Self { match value { 1 => TabType::Right, 2 => TabType::Center, 3 => TabType::Decimal, _ => TabType::Left, } } } /// 탭 정의 속성 / Tab definition attributes #[derive(Debug, Clone, Serialize, Deserialize)] pub struct TabDefAttributes { /// 문단 왼쪽 끝 자동 탭(내어 쓰기용 자동 탭) 유무 / Auto tab at paragraph left edge (hanging indent) pub has_left_auto_tab: bool, /// 문단 오른쪽 끝 자동 탭 유무 / Auto tab at paragraph right edge pub has_right_auto_tab: bool, } /// 탭 항목 / Tab item #[derive(Debug, Clone, Serialize, Deserialize)] pub struct TabItem { /// 탭의 위치 / Tab position pub position: HWPUNIT, /// 탭의 종류 / Tab type pub tab_type: TabType, /// 채움 종류 (표 25 참조) / Fill type (Table 25) pub fill_type: UINT8, } /// Tab Definition 구조체 / Tab Definition structure #[derive(Debug, Clone, Serialize, Deserialize)] pub struct TabDef { /// 속성 (표 37) / Attributes (Table 37) pub attributes: TabDefAttributes, /// 탭 개수 / Tab count pub count: INT16, /// 탭 항목 목록 / Tab items list pub tabs: Vec<TabItem>, } impl TabDef { /// TabDef를 바이트 배열에서 파싱합니다. / Parse TabDef from byte array. /// /// # Arguments /// * `data` - TabDef 레코드 데이터 / TabDef record data /// /// # Returns /// 파싱된 TabDef 구조체 / Parsed TabDef structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // 최소 6바이트 필요 (속성 4바이트 + count 2바이트) / Need at least 6 bytes (attributes 4 bytes + count 2 bytes) if data.len() < 6 { return Err(HwpError::insufficient_data("TabDef", 6, data.len())); } let mut offset = 0; // UINT32 속성 (표 37) / UINT32 attributes (Table 37) let attr_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let attributes = TabDefAttributes { has_left_auto_tab: (attr_value & 0x00000001) != 0, has_right_auto_tab: (attr_value & 0x00000002) != 0, }; // INT16 count / INT16 count let count = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // 탭 항목 파싱 (각 8바이트) / Parse tab items (8 bytes each) let mut tabs = Vec::new(); for _ in 0..count { if offset + 8 > data.len() { return Err(HwpError::InsufficientData { field: format!("TabDef tab item at offset {}", offset), expected: offset + 8, actual: data.len(), }); } // HWPUNIT 탭의 위치 / HWPUNIT tab position let position = HWPUNIT(u32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; // UINT8 탭의 종류 / UINT8 tab type let tab_type = TabType::from_byte(data[offset]); offset += 1; // UINT8 채움 종류 / UINT8 fill type let fill_type = data[offset]; offset += 1; // UINT16 예약 (8바이트 맞춤용) / UINT16 reserved (for 8-byte alignment) offset += 2; tabs.push(TabItem { position, tab_type, fill_type, }); } Ok(TabDef { attributes, count, tabs, }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/char_shape.rs

crates/hwp-core/src/document/docinfo/char_shape.rs

/// Character Shape 구조체 / Character Shape structure /// /// 스펙 문서 매핑: 표 33 - 글자 모양 / Spec mapping: Table 33 - Character shape /// Tag ID: HWPTAG_CHAR_SHAPE /// 전체 길이: 72 바이트 / Total length: 72 bytes use crate::error::HwpError; use crate::types::{COLORREF, INT32, INT8, UINT16, UINT32, UINT8, WORD}; use serde::{Deserialize, Serialize}; /// 언어별 글꼴 정보 / Language-specific font information #[derive(Debug, Clone, Serialize, Deserialize)] pub struct LanguageFontInfo { /// 한글 글꼴 ID / Korean font ID pub korean: WORD, /// 영어 글꼴 ID / English font ID pub english: WORD, /// 한자 글꼴 ID / Chinese font ID pub chinese: WORD, /// 일어 글꼴 ID / Japanese font ID pub japanese: WORD, /// 기타 글꼴 ID / Other font ID pub other: WORD, /// 기호 글꼴 ID / Symbol font ID pub symbol: WORD, /// 사용자 글꼴 ID / User font ID pub user: WORD, } /// 언어별 글자 속성 정보 (UINT8) / Language-specific character attribute information (UINT8) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct LanguageCharAttributesU8 { /// 한글 / Korean pub korean: UINT8, /// 영어 / English pub english: UINT8, /// 한자 / Chinese pub chinese: UINT8, /// 일어 / Japanese pub japanese: UINT8, /// 기타 / Other pub other: UINT8, /// 기호 / Symbol pub symbol: UINT8, /// 사용자 / User pub user: UINT8, } /// 언어별 글자 속성 정보 (INT8) / Language-specific character attribute information (INT8) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct LanguageCharAttributesI8 { /// 한글 / Korean pub korean: INT8, /// 영어 / English pub english: INT8, /// 한자 / Chinese pub chinese: INT8, /// 일어 / Japanese pub japanese: INT8, /// 기타 / Other pub other: INT8, /// 기호 / Symbol pub symbol: INT8, /// 사용자 / User pub user: INT8, } /// 글자 모양 속성 / Character shape attributes #[derive(Debug, Clone, Serialize, Deserialize)] pub struct CharShapeAttributes { /// 기울임 여부 / Italic pub italic: bool, /// 진하게 여부 / Bold pub bold: bool, /// 밑줄 종류 (0: 없음, 1: 글자 아래, 2: 글자 위) / Underline type (0: none, 1: below, 2: above) pub underline_type: UINT8, // bits 2-3 /// 밑줄 모양 (0-6) / Underline style (0-6) pub underline_style: UINT8, // bits 4-7 /// 외곽선 종류 (0: 없음, 1: 비연속, 2: 연속) / Outline type (0: none, 1: non-continuous, 2: continuous) pub outline_type: UINT8, // bits 8-10 /// 그림자 종류 / Shadow type pub shadow_type: UINT8, // bits 11-12 /// 양각 여부 / Emboss pub emboss: bool, // bit 13 /// 음각 여부 / Engrave pub engrave: bool, // bit 14 /// 위 첨자 여부 / Superscript pub superscript: bool, // bit 15 /// 아래 첨자 여부 / Subscript pub subscript: bool, // bit 16 /// 취소선 여부 (0: 없음, 1 이상: 있음) / Strikethrough (0: none, 1+: present) /// 스펙 문서 표 35: bit 18-20 / Spec Table 35: bit 18-20 pub strikethrough: UINT8, /// 강조점 종류 / Emphasis mark type pub emphasis_mark: UINT8, // bits 21-24 /// 글꼴에 어울리는 빈칸 사용 여부 / Use font-appropriate spacing pub use_font_spacing: bool, // bit 25 /// 취소선 모양 (표 25 참조) / Strikethrough style (Table 25) pub strikethrough_style: UINT8, // bits 26-29 /// Kerning 여부 / Kerning pub kerning: bool, // bit 30 } /// Character Shape 구조체 / Character Shape structure #[derive(Debug, Clone, Serialize, Deserialize)] pub struct CharShape { /// 언어별 글꼴 ID (표 34) / Language-specific font IDs (Table 34) pub font_ids: LanguageFontInfo, /// 언어별 장평, 50%~200% / Language-specific font stretch, 50%~200% pub font_stretch: LanguageCharAttributesU8, /// 언어별 자간, -50%~50% / Language-specific letter spacing, -50%~50% pub letter_spacing: LanguageCharAttributesI8, /// 언어별 상대 크기, 10%~250% / Language-specific relative size, 10%~250% pub relative_size: LanguageCharAttributesU8, /// 언어별 글자 위치, -100%~100% / Language-specific text position, -100%~100% pub text_position: LanguageCharAttributesI8, /// 기준 크기, 0pt~4096pt / Base size, 0pt~4096pt pub base_size: INT32, /// 속성 (표 35) / Attributes (Table 35) pub attributes: CharShapeAttributes, /// 그림자 간격 X, -100%~100% / Shadow spacing X, -100%~100% pub shadow_spacing_x: INT8, /// 그림자 간격 Y, -100%~100% / Shadow spacing Y, -100%~100% pub shadow_spacing_y: INT8, /// 글자 색 / Text color pub text_color: COLORREF, /// 밑줄 색 / Underline color pub underline_color: COLORREF, /// 음영 색 / Shading color pub shading_color: COLORREF, /// 그림자 색 / Shadow color pub shadow_color: COLORREF, /// 글자 테두리/배경 ID (5.0.2.1 이상) / Character border/fill ID (5.0.2.1 and above) pub border_fill_id: Option<UINT16>, /// 취소선 색 (5.0.3.0 이상) / Strikethrough color (5.0.3.0 and above) pub strikethrough_color: Option<COLORREF>, } impl CharShape { /// CharShape를 바이트 배열에서 파싱합니다. / Parse CharShape from byte array. /// /// # Arguments /// * `data` - 최소 66바이트의 데이터 (기본 66바이트, 버전에 따라 최대 72바이트) / At least 66 bytes of data (basic 66 bytes, up to 72 bytes depending on version) /// * `version` - FileHeader의 version (버전에 따라 필드 개수가 다를 수 있음) / FileHeader version (field count may vary by version) /// /// # Returns /// 파싱된 CharShape 구조체 / Parsed CharShape structure pub fn parse(data: &[u8], _version: u32) -> Result<Self, HwpError> { // 최소 66바이트 필요 / Need at least 66 bytes if data.len() < 66 { return Err(HwpError::insufficient_data("CharShape", 66, data.len())); } let mut offset = 0; // WORD array[7] 언어별 글꼴 ID / WORD array[7] language-specific font IDs let font_ids = LanguageFontInfo { korean: WORD::from_le_bytes([data[offset], data[offset + 1]]), english: WORD::from_le_bytes([data[offset + 2], data[offset + 3]]), chinese: WORD::from_le_bytes([data[offset + 4], data[offset + 5]]), japanese: WORD::from_le_bytes([data[offset + 6], data[offset + 7]]), other: WORD::from_le_bytes([data[offset + 8], data[offset + 9]]), symbol: WORD::from_le_bytes([data[offset + 10], data[offset + 11]]), user: WORD::from_le_bytes([data[offset + 12], data[offset + 13]]), }; offset += 14; // UINT8 array[7] 언어별 장평 / UINT8 array[7] language-specific font stretch let font_stretch = LanguageCharAttributesU8 { korean: data[offset] as UINT8, english: data[offset + 1] as UINT8, chinese: data[offset + 2] as UINT8, japanese: data[offset + 3] as UINT8, other: data[offset + 4] as UINT8, symbol: data[offset + 5] as UINT8, user: data[offset + 6] as UINT8, }; offset += 7; // INT8 array[7] 언어별 자간 / INT8 array[7] language-specific letter spacing // u8을 i8로 캐스팅할 때 부호 확장이 제대로 되도록 i8::from_le_bytes 사용 // Use i8::from_le_bytes to properly handle sign extension when casting u8 to i8 let letter_spacing = LanguageCharAttributesI8 { korean: i8::from_le_bytes([data[offset]]), english: i8::from_le_bytes([data[offset + 1]]), chinese: i8::from_le_bytes([data[offset + 2]]), japanese: i8::from_le_bytes([data[offset + 3]]), other: i8::from_le_bytes([data[offset + 4]]), symbol: i8::from_le_bytes([data[offset + 5]]), user: i8::from_le_bytes([data[offset + 6]]), }; offset += 7; // UINT8 array[7] 언어별 상대 크기 / UINT8 array[7] language-specific relative size let relative_size = LanguageCharAttributesU8 { korean: data[offset] as UINT8, english: data[offset + 1] as UINT8, chinese: data[offset + 2] as UINT8, japanese: data[offset + 3] as UINT8, other: data[offset + 4] as UINT8, symbol: data[offset + 5] as UINT8, user: data[offset + 6] as UINT8, }; offset += 7; // INT8 array[7] 언어별 글자 위치 / INT8 array[7] language-specific text position // u8을 i8로 캐스팅할 때 부호 확장이 제대로 되도록 i8::from_le_bytes 사용 // Use i8::from_le_bytes to properly handle sign extension when casting u8 to i8 let text_position = LanguageCharAttributesI8 { korean: i8::from_le_bytes([data[offset]]), english: i8::from_le_bytes([data[offset + 1]]), chinese: i8::from_le_bytes([data[offset + 2]]), japanese: i8::from_le_bytes([data[offset + 3]]), other: i8::from_le_bytes([data[offset + 4]]), symbol: i8::from_le_bytes([data[offset + 5]]), user: i8::from_le_bytes([data[offset + 6]]), }; offset += 7; // INT32 기준 크기 / INT32 base size let base_size = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // UINT32 속성 (표 35) / UINT32 attributes (Table 35) let attr_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // UINT32 속성 파싱 (표 35) / Parse UINT32 attributes (Table 35) let attributes = CharShapeAttributes { italic: (attr_value & 0x00000001) != 0, bold: (attr_value & 0x00000002) != 0, underline_type: ((attr_value >> 2) & 0x03) as UINT8, underline_style: ((attr_value >> 4) & 0x0F) as UINT8, outline_type: ((attr_value >> 8) & 0x07) as UINT8, shadow_type: ((attr_value >> 11) & 0x03) as UINT8, emboss: (attr_value & 0x00002000) != 0, engrave: (attr_value & 0x00004000) != 0, superscript: (attr_value & 0x00008000) != 0, subscript: (attr_value & 0x00010000) != 0, strikethrough: ((attr_value >> 18) & 0x07) as UINT8, // bit 18-20: 취소선 여부 (표 35) / bit 18-20: Strikethrough (Table 35) emphasis_mark: ((attr_value >> 21) & 0x0F) as UINT8, use_font_spacing: (attr_value & 0x02000000) != 0, strikethrough_style: ((attr_value >> 26) & 0x0F) as UINT8, kerning: (attr_value & 0x40000000) != 0, }; // INT8 그림자 간격 X / INT8 shadow spacing X let shadow_spacing_x = data[offset] as INT8; offset += 1; // INT8 그림자 간격 Y / INT8 shadow spacing Y let shadow_spacing_y = data[offset] as INT8; offset += 1; // COLORREF 글자 색 / COLORREF text color let text_color = COLORREF(u32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; // COLORREF 밑줄 색 / COLORREF underline color let underline_color = COLORREF(u32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; // COLORREF 음영 색 / COLORREF shading color let shading_color = COLORREF(u32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; // COLORREF 그림자 색 / COLORREF shadow color let shadow_color = COLORREF(u32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; // UINT16 글자 테두리/배경 ID (5.0.2.1 이상) / UINT16 character border/fill ID (5.0.2.1 and above) // 데이터 크기로 판단: 66바이트 이상이면 border_fill_id 필드 존재 / Determine by data size: border_fill_id exists if 66 bytes or more let border_fill_id = if data.len() >= 66 && offset + 2 <= data.len() { Some(WORD::from_le_bytes([data[offset], data[offset + 1]])) } else { None }; if border_fill_id.is_some() { offset += 2; } // COLORREF 취소선 색 (5.0.3.0 이상) / COLORREF strikethrough color (5.0.3.0 and above) // 데이터 크기로 판단: 70바이트 이상이면 strikethrough_color 필드 존재 / Determine by data size: strikethrough_color exists if 70 bytes or more let strikethrough_color = if data.len() >= 70 && offset + 4 <= data.len() { Some(COLORREF(u32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]))) } else { None }; Ok(CharShape { font_ids, font_stretch, letter_spacing, relative_size, text_position, base_size, attributes, shadow_spacing_x, shadow_spacing_y, text_color, underline_color, shading_color, shadow_color, border_fill_id, strikethrough_color, }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/border_fill.rs

crates/hwp-core/src/document/docinfo/border_fill.rs

/// Border/Fill 구조체 / Border/Fill structure /// /// 스펙 문서 매핑: 표 23 - 테두리/배경 속성 / Spec mapping: Table 23 - Border/fill properties /// Tag ID: HWPTAG_BORDER_FILL use crate::error::HwpError; use crate::types::{BYTE, COLORREF, INT16, INT32, UINT, UINT16, UINT8}; use serde::{Deserialize, Serialize}; /// 테두리선 정보 / Border line information #[derive(Debug, Clone, Serialize, Deserialize)] pub struct BorderLine { /// 테두리선 종류 (표 25) / Border line type (Table 25) pub line_type: UINT8, /// 테두리선 굵기 (표 26) / Border line width (Table 26) pub width: UINT8, /// 테두리선 색상 / Border line color pub color: COLORREF, } /// 대각선 정보 / Diagonal line information #[derive(Debug, Clone, Serialize, Deserialize)] pub struct DiagonalLine { /// 대각선 종류 (표 27) / Diagonal line type (Table 27) pub line_type: UINT8, /// 대각선 굵기 / Diagonal line thickness pub thickness: UINT8, /// 대각선 색상 / Diagonal line color pub color: COLORREF, } /// 채우기 종류 / Fill type #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "UPPERCASE")] pub enum FillType { /// 채우기 없음 / No fill None = 0x00000000, /// 단색 채우기 / Solid fill Solid = 0x00000001, /// 이미지 채우기 / Image fill Image = 0x00000002, /// 그러데이션 채우기 / Gradient fill Gradient = 0x00000004, } /// 단색 채우기 정보 / Solid fill information #[derive(Debug, Clone, Serialize, Deserialize)] pub struct SolidFill { /// 배경색 / Background color pub background_color: COLORREF, /// 무늬색 / Pattern color pub pattern_color: COLORREF, /// 무늬 종류 (표 29) / Pattern type (Table 29) pub pattern_type: INT32, } /// 그러데이션 채우기 정보 / Gradient fill information #[derive(Debug, Clone, Serialize, Deserialize)] pub struct GradientFill { /// 그러데이션 유형 (표 30) / Gradient type (Table 30) pub gradient_type: INT16, /// 그러데이션의 기울임(시작 각) / Gradient angle (start angle) pub angle: INT16, /// 그러데이션의 가로 중심(중심 X 좌표) / Gradient horizontal center (center X coordinate) pub horizontal_center: INT16, /// 그러데이션의 세로 중심(중심 Y 좌표) / Gradient vertical center (center Y coordinate) pub vertical_center: INT16, /// 그러데이션 번짐 정도(0-100) / Gradient spread (0-100) pub spread: INT16, /// 그러데이션의 색 수 / Number of gradient colors pub color_count: INT16, /// 색상이 바뀌는 곳의 위치 (color_count > 2일 경우에만) / Color change positions (only if color_count > 2) pub positions: Option<Vec<INT32>>, /// 색상 배열 / Color array pub colors: Vec<COLORREF>, } /// 이미지 채우기 정보 / Image fill information #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ImageFill { /// 이미지 채우기 유형 (표 31) / Image fill type (Table 31) pub image_fill_type: BYTE, /// 그림 정보 (표 32) / Image information (Table 32) pub image_info: Vec<u8>, // 5 bytes /// 그러데이션 번짐정도의 중심 (0..100) / Gradient spread center (0..100) pub gradient_spread_center: Option<BYTE>, /// 추가 채우기 속성 길이 / Additional fill attribute length pub additional_attributes_length: Option<UINT>, /// 추가 채우기 속성 / Additional fill attributes pub additional_attributes: Option<Vec<u8>>, } /// 채우기 정보 / Fill information #[derive(Debug, Clone, Serialize, Deserialize)] #[serde(tag = "type", rename_all = "lowercase")] #[allow(dead_code)] pub enum FillInfo { /// 채우기 없음 / No fill None, /// 단색 채우기 / Solid fill Solid(SolidFill), /// 이미지 채우기 / Image fill Image(ImageFill), /// 그러데이션 채우기 / Gradient fill Gradient(GradientFill), } /// 테두리/배경 속성 / Border/fill properties #[derive(Debug, Clone, Serialize, Deserialize)] pub struct BorderFill { /// 속성 (표 24) / Attributes (Table 24) pub attributes: BorderFillAttributes, /// 4방향 테두리선 정보 / 4-direction border line information pub borders: [BorderLine; 4], // [Left, Right, Top, Bottom] /// 대각선 정보 / Diagonal line information pub diagonal: DiagonalLine, /// 채우기 정보 / Fill information pub fill: FillInfo, } /// 테두리/배경 속성 비트 플래그 / Border/fill attribute bit flags #[derive(Debug, Clone, Serialize, Deserialize)] pub struct BorderFillAttributes { /// 3D 효과의 유무 / 3D effect presence pub has_3d_effect: bool, /// 그림자 효과의 유무 / Shadow effect presence pub has_shadow: bool, /// Slash 대각선 모양 / Slash diagonal shape pub slash_shape: u8, // bits 2-4 /// BackSlash 대각선 모양 / BackSlash diagonal shape pub backslash_shape: u8, // bits 5-7 /// Slash 대각선 꺽은선 / Slash diagonal broken line pub slash_broken_line: u8, // bits 8-9 /// BackSlash 대각선 꺽은선 / BackSlash diagonal broken line pub backslash_broken_line: bool, // bit 10 /// Slash 대각선 모양 180도 회전 여부 / Slash diagonal 180 degree rotation pub slash_rotated_180: bool, // bit 11 /// BackSlash 대각선 모양 180도 회전 여부 / BackSlash diagonal 180 degree rotation pub backslash_rotated_180: bool, // bit 12 /// 중심선 유무 / Center line presence pub has_center_line: bool, // bit 13 } impl BorderFill { /// BorderFill을 바이트 배열에서 파싱합니다. / Parse BorderFill from byte array. /// /// # Arguments /// * `data` - BorderFill 레코드 데이터 / BorderFill record data /// /// # Returns /// 파싱된 BorderFill 구조체 / Parsed BorderFill structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 32 { return Err(HwpError::insufficient_data("BorderFill", 32, data.len())); } let mut offset = 0; // UINT16 속성 (표 24) / UINT16 attributes (Table 24) let attr_value = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let attributes = BorderFillAttributes { has_3d_effect: (attr_value & 0x0001) != 0, has_shadow: (attr_value & 0x0002) != 0, slash_shape: ((attr_value >> 2) & 0x07) as u8, backslash_shape: ((attr_value >> 5) & 0x07) as u8, slash_broken_line: ((attr_value >> 8) & 0x03) as u8, backslash_broken_line: (attr_value & 0x0400) != 0, slash_rotated_180: (attr_value & 0x0800) != 0, backslash_rotated_180: (attr_value & 0x1000) != 0, has_center_line: (attr_value & 0x2000) != 0, }; // NOTE: // BorderFill의 실제 저장 포맷은 구현체/버전에 따라 2가지가 관찰됨. // (A) 스펙(표 23): line_types[4] -> widths[4] -> colors[4] // (B) 레거시(hwpjs.js): (line_type, width, color) * 4 (Left, Right, Top, Bottom) interleave // 여기서는 둘 다 파싱해보고 “더 그럴듯한” 결과를 선택한다. if data.len() < offset + 24 + 1 + 1 + 4 { return Err(HwpError::insufficient_data( "BorderFill (borders+diagonal)", offset + 24 + 1 + 1 + 4, data.len(), )); } fn score_borderline(line: &BorderLine) -> i32 { let mut s = 0; // width는 표 26: 0..=15 if line.width <= 15 { s += 3; } else { s -= 10; } // line_type는 표 25: 0..=16 (실무에서 확장값이 있을 수 있어 약간 완화) if line.line_type <= 32 { s += 2; } else { s -= 5; } // color는 COLORREF이므로 어떤 값이든 가능하지만, 0xFFFFFFFF 같은 극단값은 감점 if line.color.0 == 0xFFFFFFFF { s -= 2; } s } fn score_borders(borders: &[BorderLine; 4]) -> i32 { borders.iter().map(score_borderline).sum() } let start = offset; // (B) interleave: (line, width, color) * 4 let mut borders_interleave: [BorderLine; 4] = [ BorderLine { line_type: 0, width: 0, color: COLORREF(0), }, BorderLine { line_type: 0, width: 0, color: COLORREF(0), }, BorderLine { line_type: 0, width: 0, color: COLORREF(0), }, BorderLine { line_type: 0, width: 0, color: COLORREF(0), }, ]; let mut off_i = start; for i in 0..4 { let line_type = data[off_i]; off_i += 1; let width = data[off_i]; off_i += 1; let color = COLORREF(u32::from_le_bytes([ data[off_i], data[off_i + 1], data[off_i + 2], data[off_i + 3], ])); off_i += 4; borders_interleave[i] = BorderLine { line_type, width, color, }; } // (A) spec arrays: line_types[4], widths[4], colors[4] let mut borders_spec: [BorderLine; 4] = borders_interleave.clone(); let mut off_s = start; let line_types = [ data[off_s], data[off_s + 1], data[off_s + 2], data[off_s + 3], ]; off_s += 4; let widths = [ data[off_s], data[off_s + 1], data[off_s + 2], data[off_s + 3], ]; off_s += 4; let mut colors = [COLORREF(0); 4]; for i in 0..4 { colors[i] = COLORREF(u32::from_le_bytes([ data[off_s], data[off_s + 1], data[off_s + 2], data[off_s + 3], ])); off_s += 4; } for i in 0..4 { borders_spec[i] = BorderLine { line_type: line_types[i], width: widths[i], color: colors[i], }; } // 점수 비교로 선택 let score_i = score_borders(&borders_interleave); let score_s = score_borders(&borders_spec); let borders = if score_i >= score_s { offset = off_i; borders_interleave } else { offset = off_s; borders_spec }; // debug instrumentation removed // UINT8 대각선 종류 / UINT8 diagonal line type let diagonal_type = data[offset]; offset += 1; // UINT8 대각선 굵기 / UINT8 diagonal line thickness let diagonal_thickness = data[offset]; offset += 1; // COLORREF 대각선 색깔 / COLORREF diagonal line color let diagonal_color = COLORREF(u32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; let diagonal = DiagonalLine { line_type: diagonal_type, thickness: diagonal_thickness, color: diagonal_color, }; // BYTE stream 채우기 정보 (표 28) / BYTE stream fill information (Table 28) let fill = if offset < data.len() { Self::parse_fill_info(&data[offset..])? } else { FillInfo::None }; Ok(BorderFill { attributes, borders, diagonal, fill, }) } /// 채우기 정보 파싱 / Parse fill information fn parse_fill_info(data: &[u8]) -> Result<FillInfo, HwpError> { if data.len() < 4 { return Ok(FillInfo::None); } let mut offset = 0; // UINT 채우기 종류 / UINT fill type let fill_type_value = UINT::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let fill_type = if fill_type_value == 0x00000000 { FillType::None } else if (fill_type_value & 0x00000001) != 0 { FillType::Solid } else if (fill_type_value & 0x00000002) != 0 { FillType::Image } else if (fill_type_value & 0x00000004) != 0 { FillType::Gradient } else { return Ok(FillInfo::None); }; match fill_type { FillType::None => Ok(FillInfo::None), FillType::Solid => { if offset + 12 > data.len() { return Err(HwpError::insufficient_data( "Solid fill data", 12, data.len() - offset, )); } let background_color = COLORREF(u32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; let pattern_color = COLORREF(u32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; let pattern_type = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); Ok(FillInfo::Solid(SolidFill { background_color, pattern_color, pattern_type, })) } FillType::Gradient => { if offset + 12 > data.len() { return Err(HwpError::insufficient_data( "Gradient fill data", 12, data.len() - offset, )); } let gradient_type = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let angle = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let horizontal_center = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let vertical_center = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let spread = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let color_count = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let positions = if color_count > 2 { if offset + (4 * color_count as usize) > data.len() { return Err(HwpError::insufficient_data( "Gradient positions data", 4 * color_count as usize, data.len() - offset, )); } let mut pos_vec = Vec::new(); for _ in 0..color_count { pos_vec.push(INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; } Some(pos_vec) } else { None }; if offset + (4 * color_count as usize) > data.len() { return Err(HwpError::insufficient_data( "Gradient colors data", 4 * color_count as usize, data.len() - offset, )); } let mut colors = Vec::new(); for _ in 0..color_count { colors.push(COLORREF(u32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]))); offset += 4; } Ok(FillInfo::Gradient(GradientFill { gradient_type, angle, horizontal_center, vertical_center, spread, color_count, positions, colors, })) } FillType::Image => { // 이미지 채우기는 복잡하므로 기본 구조만 파싱 / Image fill is complex, so only parse basic structure if offset + 1 > data.len() { return Err(HwpError::insufficient_data( "Image fill type", 1, data.len() - offset, )); } let image_fill_type = data[offset]; offset += 1; if offset + 5 > data.len() { return Err(HwpError::insufficient_data( "Image info", 5, data.len() - offset, )); } let image_info = data[offset..offset + 5].to_vec(); offset += 5; // 나머지는 복잡하므로 일단 기본 구조만 / Rest is complex, so only basic structure for now Ok(FillInfo::Image(ImageFill { image_fill_type, image_info, gradient_spread_center: None, additional_attributes_length: None, additional_attributes: None, })) } } } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/face_name.rs

crates/hwp-core/src/document/docinfo/face_name.rs

/// Face Name (Font) 구조체 / Face Name (Font) structure /// /// 스펙 문서 매핑: 표 19 - 글꼴 / Spec mapping: Table 19 - Font /// Tag ID: HWPTAG_FACE_NAME use crate::error::HwpError; use crate::types::{decode_utf16le, BYTE, WORD}; use serde::{Deserialize, Serialize}; /// 글꼴 속성 플래그 / Font attribute flags mod flags { /// 대체 글꼴 존재 여부 / Alternative font exists pub const HAS_ALTERNATIVE: u8 = 0x80; /// 글꼴 유형 정보 존재 여부 / Font type information exists pub const HAS_TYPE_INFO: u8 = 0x40; /// 기본 글꼴 존재 여부 / Default font exists pub const HAS_DEFAULT: u8 = 0x20; } /// 대체 글꼴 유형 / Alternative font type #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "UPPERCASE")] pub enum AlternativeFontType { /// 원래 종류를 알 수 없을 때 / Unknown original type Unknown = 0, /// 트루타입 글꼴(TTF) / TrueType font (TTF) TTF = 1, /// 한글 전용 글꼴(HFT) / HWP font (HFT) HFT = 2, } impl AlternativeFontType { /// BYTE 값에서 AlternativeFontType 생성 / Create AlternativeFontType from BYTE value fn from_byte(value: BYTE) -> Self { match value { 1 => AlternativeFontType::TTF, 2 => AlternativeFontType::HFT, _ => AlternativeFontType::Unknown, } } } /// 글꼴 유형 정보 / Font type information #[derive(Debug, Clone, Serialize, Deserialize)] pub struct FontTypeInfo { /// 글꼴 계열 / Font family pub font_family: BYTE, /// 세리프 유형 / Serif type pub serif: BYTE, /// 굵기 / Boldness pub bold: BYTE, /// 비례 / Proportion pub proportion: BYTE, /// 대조 / Contrast pub contrast: BYTE, /// 스트로크 편차 / Stroke variation pub stroke_variation: BYTE, /// 자획 유형 / Stroke type pub stroke_type: BYTE, /// 글자형 / Letter type pub letter_type: BYTE, /// 중간선 / Middle line pub middle_line: BYTE, /// X-높이 / X-height pub x_height: BYTE, } /// Face Name (Font) 구조체 / Face Name (Font) structure #[derive(Debug, Clone, Serialize, Deserialize)] pub struct FaceName { /// 글꼴 이름 / Font name pub name: String, /// 대체 글꼴 유형 (속성에 따라 존재) / Alternative font type (exists based on attribute) pub alternative_font_type: Option<AlternativeFontType>, /// 대체 글꼴 이름 (속성에 따라 존재) / Alternative font name (exists based on attribute) pub alternative_font_name: Option<String>, /// 글꼴 유형 정보 (속성에 따라 존재) / Font type information (exists based on attribute) pub font_type_info: Option<FontTypeInfo>, /// 기본 글꼴 이름 (속성에 따라 존재) / Default font name (exists based on attribute) pub default_font_name: Option<String>, } impl FaceName { /// FaceName을 바이트 배열에서 파싱합니다. / Parse FaceName from byte array. /// /// # Arguments /// * `data` - FaceName 레코드 데이터 / FaceName record data /// /// # Returns /// 파싱된 FaceName 구조체 / Parsed FaceName structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 3 { return Err(HwpError::insufficient_data("FaceName", 3, data.len())); } let mut offset = 0; // BYTE 속성 (표 20) / BYTE attribute (Table 20) let attributes = data[offset]; offset += 1; // WORD 글꼴 이름 길이 / WORD font name length let name_length = WORD::from_le_bytes([data[offset], data[offset + 1]]) as usize; offset += 2; // WCHAR array 글꼴 이름 / WCHAR array font name if offset + (name_length * 2) > data.len() { return Err(HwpError::InsufficientData { field: format!("FaceName font name at offset {}", offset), expected: offset + (name_length * 2), actual: data.len(), }); } let name_bytes = &data[offset..offset + (name_length * 2)]; let name = decode_utf16le(name_bytes) .map_err(|e| HwpError::EncodingError { reason: format!("Failed to decode font name: {}", e), })?; offset += name_length * 2; // 대체 글꼴 처리 (속성 bit 7이 1인 경우) / Process alternative font (if attribute bit 7 is 1) let (alternative_font_type, alternative_font_name) = if (attributes & flags::HAS_ALTERNATIVE) != 0 { if offset >= data.len() { return Err(HwpError::insufficient_data( "FaceName alternative font type", 1, 0, )); } let alt_type_byte = data[offset]; offset += 1; // WORD 대체 글꼴 이름 길이 / WORD alternative font name length if offset + 2 > data.len() { return Err(HwpError::insufficient_data( "FaceName alternative font name length", 2, data.len() - offset, )); } let alt_name_length = WORD::from_le_bytes([data[offset], data[offset + 1]]) as usize; offset += 2; // WCHAR array 대체 글꼴 이름 / WCHAR array alternative font name if offset + (alt_name_length * 2) > data.len() { return Err(HwpError::InsufficientData { field: format!("FaceName alternative font name at offset {}", offset), expected: offset + (alt_name_length * 2), actual: data.len(), }); } let alt_name_bytes = &data[offset..offset + (alt_name_length * 2)]; let alt_name = decode_utf16le(alt_name_bytes) .map_err(|e| HwpError::EncodingError { reason: format!("Failed to decode alternative font name: {}", e), })?; offset += alt_name_length * 2; ( Some(AlternativeFontType::from_byte(alt_type_byte)), Some(alt_name), ) } else { (None, None) }; // 글꼴 유형 정보 처리 (속성 bit 6이 1인 경우) / Process font type info (if attribute bit 6 is 1) let font_type_info = if (attributes & flags::HAS_TYPE_INFO) != 0 { if offset + 10 > data.len() { return Err(HwpError::insufficient_data( "FaceName font type info", 10, data.len() - offset, )); } Some(FontTypeInfo { font_family: data[offset], serif: data[offset + 1], bold: data[offset + 2], proportion: data[offset + 3], contrast: data[offset + 4], stroke_variation: data[offset + 5], stroke_type: data[offset + 6], letter_type: data[offset + 7], middle_line: data[offset + 8], x_height: data[offset + 9], }) } else { None }; if font_type_info.is_some() { offset += 10; } // 기본 글꼴 처리 (속성 bit 5가 1인 경우) / Process default font (if attribute bit 5 is 1) let default_font_name = if (attributes & flags::HAS_DEFAULT) != 0 { if offset + 2 > data.len() { return Err(HwpError::insufficient_data( "FaceName default font name length", 2, data.len() - offset, )); } let default_name_length = WORD::from_le_bytes([data[offset], data[offset + 1]]) as usize; offset += 2; if offset + (default_name_length * 2) > data.len() { return Err(HwpError::InsufficientData { field: format!("FaceName default font name at offset {}", offset), expected: offset + (default_name_length * 2), actual: data.len(), }); } let default_name_bytes = &data[offset..offset + (default_name_length * 2)]; let default_name = decode_utf16le(default_name_bytes) .map_err(|e| HwpError::EncodingError { reason: format!("Failed to decode default font name: {}", e), })?; Some(default_name) } else { None }; Ok(FaceName { name, alternative_font_type, alternative_font_name, font_type_info, default_font_name, }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/memo_shape.rs

crates/hwp-core/src/document/docinfo/memo_shape.rs

/// MemoShape 구조체 / MemoShape structure /// /// 스펙 문서 매핑: 표 4 - 메모 모양 / Spec mapping: Table 4 - Memo shape /// 상세 구조는 스펙 문서에 명시되지 않음 / Detailed structure not specified in spec use crate::error::HwpError; use serde::{Deserialize, Serialize}; /// 메모 모양 / Memo shape #[derive(Debug, Clone, Serialize, Deserialize)] pub struct MemoShape { /// Raw data (22바이트) / Raw data (22 bytes) #[serde(skip)] pub raw_data: Vec<u8>, } impl MemoShape { /// MemoShape를 바이트 배열에서 파싱합니다. / Parse MemoShape from byte array. /// /// # Arguments /// * `data` - MemoShape 데이터 (22바이트) / MemoShape data (22 bytes) /// /// # Returns /// 파싱된 MemoShape 구조체 / Parsed MemoShape structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 22 { return Err(HwpError::insufficient_data("MemoShape", 22, data.len())); } Ok(MemoShape { raw_data: data[0..22.min(data.len())].to_vec(), }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/bullet.rs

crates/hwp-core/src/document/docinfo/bullet.rs

/// Bullet 구조체 / Bullet structure /// /// 스펙 문서 매핑: 표 42 - 글머리표 / Spec mapping: Table 42 - Bullet /// Tag ID: HWPTAG_BULLET /// 전체 길이: 20바이트 (표 42) 또는 가변 (레거시 코드 기준) / Total length: 20 bytes (Table 42) or variable (legacy code) use crate::error::HwpError; use crate::types::{BYTE, HWPUNIT16, INT32, UINT32, WCHAR}; use serde::{Deserialize, Serialize}; /// 문단 머리 정보 속성 / Paragraph header information attributes /// /// 표 40 참조 / See Table 40 #[derive(Debug, Clone, Serialize, Deserialize)] pub struct BulletHeaderAttributes { /// 문단의 정렬 종류 / Paragraph alignment type pub align_type: BulletAlignType, /// 인스턴스 유사 여부 (bit 2) / Instance-like flag (bit 2) pub instance_like: bool, /// 자동 내어 쓰기 여부 / Auto outdent flag pub auto_outdent: bool, /// 수준별 본문과의 거리 종류 / Distance type from body text by level pub distance_type: BulletDistanceType, } /// 문단 정렬 종류 / Paragraph alignment type #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum BulletAlignType { /// 왼쪽 / Left Left = 0, /// 가운데 / Center Center = 1, /// 오른쪽 / Right Right = 2, } impl BulletAlignType { fn from_bits(bits: u32) -> Self { match bits & 0x00000003 { 1 => BulletAlignType::Center, 2 => BulletAlignType::Right, _ => BulletAlignType::Left, } } } /// 수준별 본문과의 거리 종류 / Distance type from body text by level #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum BulletDistanceType { /// 글자 크기에 대한 상대 비율 / Relative ratio to font size Ratio = 0, /// 값 / Value Value = 1, } impl BulletDistanceType { fn from_bit(bit: bool) -> Self { if bit { BulletDistanceType::Value } else { BulletDistanceType::Ratio } } } /// 이미지 글머리표 속성 / Image bullet attributes #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ImageBulletAttributes { /// 명암 / Brightness pub brightness: BYTE, /// 밝기 / Contrast pub contrast: BYTE, /// 효과 / Effect pub effect: BYTE, /// ID / ID pub id: BYTE, } /// Bullet 구조체 / Bullet structure #[derive(Debug, Clone, Serialize, Deserialize)] pub struct Bullet { /// 속성 (표 40) / Attributes (Table 40) pub attributes: BulletHeaderAttributes, /// 너비 보정값 / Width correction value pub width: HWPUNIT16, /// 본문과의 거리 / Distance from body text pub space: HWPUNIT16, /// 글자 모양 아이디 참조 / Character shape ID reference pub char_shape_id: INT32, /// 글머리표 문자 / Bullet character pub bullet_char: WCHAR, /// 이미지 글머리표 존재 여부(ID) / Image bullet existence (ID) pub image_bullet_id: INT32, /// 이미지 글머리표 속성 (명암, 밝기, 효과, ID) / Image bullet attributes (brightness, contrast, effect, ID) pub image_bullet_attributes: Option<ImageBulletAttributes>, /// 체크 글머리표 문자 / Check bullet character pub check_bullet_char: WCHAR, } impl Bullet { /// Bullet을 바이트 배열에서 파싱합니다. / Parse Bullet from byte array. /// /// # Arguments /// * `data` - Bullet 레코드 데이터 / Bullet record data /// /// # Returns /// 파싱된 Bullet 구조체 / Parsed Bullet structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // 레거시 코드 기준 최소 12바이트 필요 (속성 4 + 너비 2 + 거리 2 + 글자모양ID 4) / Need at least 12 bytes based on legacy code if data.len() < 12 { return Err(HwpError::insufficient_data("Bullet", 12, data.len())); } let mut offset = 0; // UINT 속성 (표 40) - 레거시 코드 기준 / UINT attributes (Table 40) - based on legacy code let attr_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let attributes = BulletHeaderAttributes { align_type: BulletAlignType::from_bits(attr_value), instance_like: (attr_value & 0x00000004) != 0, auto_outdent: (attr_value & 0x00000008) != 0, distance_type: BulletDistanceType::from_bit((attr_value & 0x00000010) != 0), }; // HWPUNIT16 너비 보정값 / HWPUNIT16 width correction value let width = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // HWPUNIT16 본문과의 거리 / HWPUNIT16 distance from body text let space = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // INT32 글자 모양 아이디 참조 / INT32 character shape ID reference let char_shape_id = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // WCHAR 글머리표 문자 / WCHAR bullet character let bullet_char = if offset + 2 <= data.len() { WCHAR::from_le_bytes([data[offset], data[offset + 1]]) } else { 0 }; offset += 2; // INT32 이미지 글머리표 존재 여부(ID) - 옵션 / INT32 image bullet existence (ID) - optional let image_bullet_id = if offset + 4 <= data.len() { INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]) } else { 0 }; offset += 4; // BYTE stream 이미지 글머리표 속성 (4바이트) - 옵션 / BYTE stream image bullet attributes (4 bytes) - optional let image_bullet_attributes = if offset + 4 <= data.len() { Some(ImageBulletAttributes { brightness: data[offset], contrast: data[offset + 1], effect: data[offset + 2], id: data[offset + 3], }) } else { None }; offset += 4; // WCHAR 체크 글머리표 문자 - 옵션 / WCHAR check bullet character - optional let check_bullet_char = if offset + 2 <= data.len() { WCHAR::from_le_bytes([data[offset], data[offset + 1]]) } else { 0 }; Ok(Bullet { attributes, width, space, char_shape_id, bullet_char, image_bullet_id, image_bullet_attributes, check_bullet_char, }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/track_change_content.rs

crates/hwp-core/src/document/docinfo/track_change_content.rs

/// TrackChangeContent 구조체 / TrackChangeContent structure /// /// 스펙 문서 매핑: 표 4 - 변경 추적 내용 및 모양 / Spec mapping: Table 4 - Track change content and shape /// 상세 구조는 스펙 문서에 명시되지 않음 / Detailed structure not specified in spec use crate::error::HwpError; use serde::{Deserialize, Serialize}; /// 변경 추적 내용 및 모양 / Track change content and shape #[derive(Debug, Clone, Serialize, Deserialize)] pub struct TrackChangeContent { /// Raw data (가변) / Raw data (variable) #[serde(skip)] pub raw_data: Vec<u8>, } impl TrackChangeContent { /// TrackChangeContent를 바이트 배열에서 파싱합니다. / Parse TrackChangeContent from byte array. /// /// # Arguments /// * `data` - TrackChangeContent 데이터 (가변) / TrackChangeContent data (variable) /// /// # Returns /// 파싱된 TrackChangeContent 구조체 / Parsed TrackChangeContent structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { Ok(TrackChangeContent { raw_data: data.to_vec(), }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/distribute_doc_data.rs

crates/hwp-core/src/document/docinfo/distribute_doc_data.rs

/// DistributeDocData 구조체 / DistributeDocData structure /// /// 스펙 문서 매핑: 표 53 - 배포용 문서 데이터 / Spec mapping: Table 53 - Distribution document data use crate::error::HwpError; use serde::{Deserialize, Serialize}; /// 배포용 문서 데이터 (표 53) / Distribution document data (Table 53) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct DistributeDocData { /// 배포용 문서 데이터 (256바이트) / Distribution document data (256 bytes) pub data: Vec<u8>, } impl DistributeDocData { /// DistributeDocData를 바이트 배열에서 파싱합니다. / Parse DistributeDocData from byte array. /// /// # Arguments /// * `data` - DistributeDocData 데이터 (256바이트) / DistributeDocData data (256 bytes) /// /// # Returns /// 파싱된 DistributeDocData 구조체 / Parsed DistributeDocData structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 256 { return Err(HwpError::insufficient_data("DistributeDocData", 256, data.len())); } let doc_data = data[0..256].to_vec(); Ok(DistributeDocData { data: doc_data }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/bin_data.rs

crates/hwp-core/src/document/docinfo/bin_data.rs

/// BinData record structure /// /// This module handles parsing of HWPTAG_BIN_DATA records from DocInfo. /// /// 스펙 문서 매핑: 표 17 - 바이너리 데이터 / Spec mapping: Table 17 - Binary data /// Tag ID: HWPTAG_BIN_DATA use crate::error::HwpError; use crate::types::{decode_utf16le, UINT16, WORD}; use serde::{Deserialize, Serialize}; /// 바이너리 데이터 저장 타입 / Binary data storage type #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "UPPERCASE")] pub enum BinDataStorageType { /// LINK, 그림 외부 파일 참조 / Link, external file reference Link = 0x0000, /// EMBEDDING, 그림 파일 포함 / Embedding, embedded file Embedding = 0x0001, /// STORAGE, OLE 포함 / Storage, OLE embedded Storage = 0x0002, } impl BinDataStorageType { /// UINT16 값에서 BinDataStorageType 생성 / Create BinDataStorageType from UINT16 value fn from_u16(value: UINT16) -> Self { match value & 0x000F { 0x0000 => BinDataStorageType::Link, 0x0001 => BinDataStorageType::Embedding, 0x0002 => BinDataStorageType::Storage, _ => BinDataStorageType::Link, // Default fallback } } } /// 압축 타입 / Compression type #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum CompressionType { /// 스토리지의 디폴트 모드 따라감 / Follow storage default mode StorageDefault = 0x0000, /// 무조건 압축 / Always compress Compress = 0x0010, /// 무조건 압축하지 않음 / Never compress NoCompress = 0x0020, } impl CompressionType { /// UINT16 값에서 CompressionType 생성 / Create CompressionType from UINT16 value fn from_u16(value: UINT16) -> Self { match value & 0x0030 { 0x0000 => CompressionType::StorageDefault, 0x0010 => CompressionType::Compress, 0x0020 => CompressionType::NoCompress, _ => CompressionType::StorageDefault, // Default fallback } } } /// 접근 상태 / Access state #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum AccessState { /// 아직 access 된 적이 없는 상태 / Never accessed Never = 0x0000, /// access에 성공하여 파일을 찾은 상태 / Successfully accessed, file found Success = 0x0100, /// access가 실패한 에러 상태 / Access failed with error Failed = 0x0200, /// 링크 access가 실패했으나 무시된 상태 / Link access failed but ignored FailedIgnored = 0x0300, } impl AccessState { /// UINT16 값에서 AccessState 생성 / Create AccessState from UINT16 value fn from_u16(value: UINT16) -> Self { match value & 0x0300 { 0x0000 => AccessState::Never, 0x0100 => AccessState::Success, 0x0200 => AccessState::Failed, 0x0300 => AccessState::FailedIgnored, _ => AccessState::Never, // Default fallback } } } /// 바이너리 데이터 속성 / Binary data attributes #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct BinDataAttributes { /// 저장 타입 / Storage type pub storage_type: BinDataStorageType, /// 압축 타입 / Compression type pub compression: CompressionType, /// 접근 상태 / Access state pub access: AccessState, } impl BinDataAttributes { /// UINT16 값에서 BinDataAttributes 생성 / Create BinDataAttributes from UINT16 value fn from_u16(value: UINT16) -> Self { Self { storage_type: BinDataStorageType::from_u16(value), compression: CompressionType::from_u16(value), access: AccessState::from_u16(value), } } } /// LINK 타입 데이터 / Link type data #[derive(Debug, Clone, Serialize, Deserialize)] pub struct BinDataLink { /// 연결 파일의 절대 경로 / Absolute path of linked file pub absolute_path: String, /// 연결 파일의 상대 경로 / Relative path of linked file pub relative_path: String, } /// EMBEDDING 타입 데이터 / Embedding type data #[derive(Debug, Clone, Serialize, Deserialize)] pub struct BinDataEmbedding { /// BINDATASTORAGE에 저장된 바이너리 데이터의 아이디 / Binary data ID stored in BINDATASTORAGE pub binary_data_id: UINT16, /// 바이너리 데이터의 형식 이름 (extension, "." 제외) / Format name (extension without ".") /// - 그림의 경우: jpg, bmp, gif / For images: jpg, bmp, gif /// - OLE의 경우: ole / For OLE: ole pub extension: String, } /// STORAGE 타입 데이터 / Storage type data #[derive(Debug, Clone, Serialize, Deserialize)] pub struct BinDataStorage { /// BINDATASTORAGE에 저장된 바이너리 데이터의 아이디 / Binary data ID stored in BINDATASTORAGE pub binary_data_id: UINT16, } /// 바이너리 데이터 레코드 / Binary data record #[derive(Debug, Clone, Serialize, Deserialize)] #[serde(tag = "storage_type", rename_all = "UPPERCASE")] pub enum BinDataRecord { /// LINK 타입 / Link type Link { /// 속성 / Attributes attributes: BinDataAttributes, /// LINK 데이터 / Link data link: BinDataLink, }, /// EMBEDDING 타입 / Embedding type Embedding { /// 속성 / Attributes attributes: BinDataAttributes, /// EMBEDDING 데이터 / Embedding data embedding: BinDataEmbedding, }, /// STORAGE 타입 / Storage type Storage { /// 속성 / Attributes attributes: BinDataAttributes, /// STORAGE 데이터 / Storage data storage: BinDataStorage, }, } impl BinDataRecord { /// BinDataRecord를 바이트 배열에서 파싱합니다. / Parse BinDataRecord from byte array. /// /// # Arguments /// * `data` - BinDataRecord 데이터 / BinDataRecord data /// /// # Returns /// 파싱된 BinDataRecord 구조체 / Parsed BinDataRecord structure /// /// # 스펙 문서 매핑 / Spec mapping /// 표 17: 바이너리 데이터 / Table 17: Binary data pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 2 { return Err(HwpError::insufficient_data("BinDataRecord attributes", 2, data.len())); } let mut offset = 0; // 표 17: 속성 (UINT16, 2바이트) / Table 17: Attributes (UINT16, 2 bytes) let attr_value = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let attributes = BinDataAttributes::from_u16(attr_value); // Type에 따라 다른 필드 파싱 / Parse different fields based on type match attributes.storage_type { BinDataStorageType::Link => { // 표 17: Type이 "LINK"일 때 / Table 17: When Type is "LINK" // 연결 파일의 절대 경로 길이 (len1) / Absolute path length (len1) if data.len() < offset + 2 { return Err(HwpError::insufficient_data( "BinDataRecord LINK absolute path length", 2, data.len() - offset, )); } let len1 = WORD::from_le_bytes([data[offset], data[offset + 1]]) as usize; offset += 2; // 연결 파일의 절대 경로 / Absolute path if data.len() < offset + (len1 * 2) { return Err(HwpError::InsufficientData { field: format!("BinDataRecord LINK absolute path at offset {}", offset), expected: offset + (len1 * 2), actual: data.len(), }); } let absolute_path_bytes = &data[offset..offset + (len1 * 2)]; let absolute_path = decode_utf16le(absolute_path_bytes) .map_err(|e| HwpError::EncodingError { reason: format!("Failed to decode absolute path: {}", e), })?; offset += len1 * 2; // 연결 파일의 상대 경로 길이 (len2) / Relative path length (len2) if data.len() < offset + 2 { return Err(HwpError::insufficient_data( "BinDataRecord LINK relative path length", 2, data.len() - offset, )); } let len2 = WORD::from_le_bytes([data[offset], data[offset + 1]]) as usize; offset += 2; // 연결 파일의 상대 경로 / Relative path if data.len() < offset + (len2 * 2) { return Err(HwpError::InsufficientData { field: format!("BinDataRecord LINK relative path at offset {}", offset), expected: offset + (len2 * 2), actual: data.len(), }); } let relative_path_bytes = &data[offset..offset + (len2 * 2)]; let relative_path = decode_utf16le(relative_path_bytes) .map_err(|e| HwpError::EncodingError { reason: format!("Failed to decode relative path: {}", e), })?; Ok(BinDataRecord::Link { attributes, link: BinDataLink { absolute_path, relative_path, }, }) } BinDataStorageType::Embedding => { // 표 17: Type이 "EMBEDDING"일 때 / Table 17: When Type is "EMBEDDING" // BINDATASTORAGE에 저장된 바이너리 데이터의 아이디 / Binary data ID if data.len() < offset + 2 { return Err(HwpError::insufficient_data( "BinDataRecord EMBEDDING binary_data_id", 2, data.len() - offset, )); } let binary_data_id = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // 바이너리 데이터의 형식 이름의 길이 (len3) / Format name length (len3) if data.len() < offset + 2 { return Err(HwpError::insufficient_data( "BinDataRecord EMBEDDING extension length", 2, data.len() - offset, )); } let len3 = WORD::from_le_bytes([data[offset], data[offset + 1]]) as usize; offset += 2; // 바이너리 데이터의 형식 이름 (extension) / Format name (extension) if data.len() < offset + (len3 * 2) { return Err(HwpError::InsufficientData { field: format!("BinDataRecord EMBEDDING extension at offset {}", offset), expected: offset + (len3 * 2), actual: data.len(), }); } let extension_bytes = &data[offset..offset + (len3 * 2)]; let extension = decode_utf16le(extension_bytes) .map_err(|e| HwpError::EncodingError { reason: format!("Failed to decode extension: {}", e), })?; Ok(BinDataRecord::Embedding { attributes, embedding: BinDataEmbedding { binary_data_id, extension, }, }) } BinDataStorageType::Storage => { // 표 17: Type이 "STORAGE"일 때 / Table 17: When Type is "STORAGE" // BINDATASTORAGE에 저장된 바이너리 데이터의 아이디 / Binary data ID if data.len() < offset + 2 { return Err(HwpError::insufficient_data( "BinDataRecord STORAGE binary_data_id", 2, data.len() - offset, )); } let binary_data_id = UINT16::from_le_bytes([data[offset], data[offset + 1]]); Ok(BinDataRecord::Storage { attributes, storage: BinDataStorage { binary_data_id }, }) } } } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/compatible_document.rs

crates/hwp-core/src/document/docinfo/compatible_document.rs

/// CompatibleDocument 구조체 / CompatibleDocument structure /// /// 스펙 문서 매핑: 표 54 - 호환 문서 / Spec mapping: Table 54 - Compatible document use crate::error::HwpError; use crate::types::UINT32; use serde::{Deserialize, Serialize}; /// 호환 문서 (표 54) / Compatible document (Table 54) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct CompatibleDocument { /// 대상 프로그램 (표 55 참조) / Target program (see Table 55) pub target_program: TargetProgram, } /// 대상 프로그램 (표 55) / Target program (Table 55) #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum TargetProgram { /// 한글 문서(현재 버전) / HWP document (current version) HwpCurrent, /// 한글 2007 호환 문서 / HWP 2007 compatible document Hwp2007, /// MS 워드 호환 문서 / MS Word compatible document MsWord, } impl CompatibleDocument { /// CompatibleDocument를 바이트 배열에서 파싱합니다. / Parse CompatibleDocument from byte array. /// /// # Arguments /// * `data` - CompatibleDocument 데이터 (4바이트) / CompatibleDocument data (4 bytes) /// /// # Returns /// 파싱된 CompatibleDocument 구조체 / Parsed CompatibleDocument structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 4 { return Err(HwpError::insufficient_data("CompatibleDocument", 4, data.len())); } let target_program_value = UINT32::from_le_bytes([data[0], data[1], data[2], data[3]]); let target_program = match target_program_value { 0 => TargetProgram::HwpCurrent, 1 => TargetProgram::Hwp2007, 2 => TargetProgram::MsWord, _ => { return Err(HwpError::UnexpectedValue { field: "CompatibleDocument target_program".to_string(), expected: "0, 1, or 2".to_string(), found: target_program_value.to_string(), }); } }; Ok(CompatibleDocument { target_program }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/mod.rs

crates/hwp-core/src/document/docinfo/mod.rs

/// DocInfo parsing module /// /// This module handles parsing of HWP DocInfo stream. /// /// 스펙 문서 매핑: 표 2 - 문서 정보 (DocInfo 스트림) / Spec mapping: Table 2 - Document information (DocInfo stream) pub mod bin_data; pub mod border_fill; pub mod bullet; pub mod char_shape; pub mod compatible_document; pub mod constants; pub mod distribute_doc_data; pub mod doc_data; pub mod document_properties; pub mod face_name; pub mod forbidden_char; pub mod id_mappings; pub mod layout_compatibility; pub mod memo_shape; pub mod numbering; pub mod para_shape; pub mod style; pub mod tab_def; pub mod track_change; pub mod track_change_author; pub mod track_change_content; pub use crate::decompress::decompress_deflate; pub use crate::document::fileheader::FileHeader; pub use crate::error::HwpError; pub use crate::types::RecordHeader; pub use bin_data::BinDataRecord; pub use border_fill::{BorderFill, FillInfo}; pub use bullet::Bullet; pub use char_shape::CharShape; pub use compatible_document::CompatibleDocument; pub use constants::HwpTag; pub use distribute_doc_data::DistributeDocData; pub use doc_data::{DocData, ParameterSet}; pub use document_properties::DocumentProperties; pub use face_name::FaceName; pub use forbidden_char::ForbiddenChar; pub use id_mappings::IdMappings; pub use layout_compatibility::LayoutCompatibility; pub use memo_shape::MemoShape; pub use numbering::Numbering; pub use para_shape::{HeaderShapeType, ParaShape}; use serde::{Deserialize, Serialize}; pub use style::Style; pub use tab_def::TabDef; pub use track_change::TrackChange; pub use track_change_author::TrackChangeAuthor; pub use track_change_content::TrackChangeContent; /// Document information structure #[derive(Debug, Clone, Default, Serialize, Deserialize)] pub struct DocInfo { /// Document properties (parsed) pub document_properties: Option<DocumentProperties>, /// ID mappings (parsed) pub id_mappings: Option<IdMappings>, /// Binary data records (parsed) / 바이너리 데이터 레코드 (파싱됨) pub bin_data: Vec<BinDataRecord>, /// Face names (fonts) (parsed) / 글꼴 목록 (파싱됨) pub face_names: Vec<FaceName>, /// Border/fill information (parsed) / 테두리/배경 정보 (파싱됨) pub border_fill: Vec<BorderFill>, /// Character shapes (parsed) / 글자 모양 (파싱됨) pub char_shapes: Vec<CharShape>, /// Tab definitions (parsed) / 탭 정의 (파싱됨) pub tab_defs: Vec<TabDef>, /// Numbering information (parsed) / 문단 번호 정보 (파싱됨) pub numbering: Vec<Numbering>, /// Bullet information (parsed) / 글머리표 정보 (파싱됨) pub bullets: Vec<Bullet>, /// Paragraph shapes (parsed) / 문단 모양 (파싱됨) pub para_shapes: Vec<ParaShape>, /// Styles (parsed) / 스타일 (파싱됨) pub styles: Vec<Style>, /// Document arbitrary data (parsed) / 문서 임의의 데이터 (파싱됨) pub doc_data: Vec<DocData>, /// Distribution document data (parsed) / 배포용 문서 데이터 (파싱됨) pub distribute_doc_data: Option<DistributeDocData>, /// Compatible document (parsed) / 호환 문서 (파싱됨) pub compatible_document: Option<CompatibleDocument>, /// Layout compatibility (parsed) / 레이아웃 호환성 (파싱됨) pub layout_compatibility: Option<LayoutCompatibility>, /// Track change information (parsed) / 변경 추적 정보 (파싱됨) pub track_change: Option<TrackChange>, /// Memo shapes (parsed) / 메모 모양 (파싱됨) pub memo_shapes: Vec<MemoShape>, /// Forbidden characters (parsed) / 금칙처리 문자 (파싱됨) pub forbidden_chars: Vec<ForbiddenChar>, /// Track change contents (parsed) / 변경 추적 내용 및 모양 (파싱됨) pub track_change_contents: Vec<TrackChangeContent>, /// Track change authors (parsed) / 변경 추적 작성자 (파싱됨) pub track_change_authors: Vec<TrackChangeAuthor>, } impl DocInfo { /// DocInfo 스트림을 파싱합니다. / Parse DocInfo stream. /// /// # Arguments /// * `stream_data` - DocInfo 스트림의 원시 바이트 데이터 / Raw byte data of DocInfo stream /// * `file_header` - FileHeader (압축 여부 확인용) / FileHeader (to check compression) /// /// # Returns /// 파싱된 DocInfo 구조체 / Parsed DocInfo structure pub fn parse(stream_data: &[u8], file_header: &FileHeader) -> Result<Self, HwpError> { // 압축 해제 (필요한 경우) / Decompress if needed // HWP DocInfo uses raw deflate format (windowBits: -15), not zlib let decompressed_data = if file_header.is_compressed() { decompress_deflate(stream_data)? } else { stream_data.to_vec() }; let mut doc_info = DocInfo::default(); let mut offset = 0; // 레코드 단위로 파싱 / Parse record by record while offset < decompressed_data.len() { // 레코드 헤더 파싱 / Parse record header let remaining_data = &decompressed_data[offset..]; let (header, header_size) = RecordHeader::parse(remaining_data).map_err(|e| HwpError::from(e))?; offset += header_size; // 데이터 영역 읽기 / Read data area let data_size = header.size as usize; if offset + data_size > decompressed_data.len() { return Err(HwpError::InsufficientData { field: format!("DocInfo record at offset {}", offset), expected: offset + data_size, actual: decompressed_data.len(), }); } let record_data = &decompressed_data[offset..offset + data_size]; offset += data_size; // 태그별로 분류하여 저장 / Classify and store by tag match header.tag_id { HwpTag::DOCUMENT_PROPERTIES => { if header.level == 0 { // DocumentProperties는 완전히 파싱 / Fully parse DocumentProperties let props = DocumentProperties::parse(record_data) .map_err(|e| HwpError::from(e))?; doc_info.document_properties = Some(props); } } HwpTag::ID_MAPPINGS => { if header.level == 0 { // IdMappings는 완전히 파싱 / Fully parse IdMappings let id_mappings = IdMappings::parse(record_data, file_header.version) .map_err(|e| HwpError::from(e))?; doc_info.id_mappings = Some(id_mappings); } } HwpTag::BIN_DATA => { if header.level == 1 { // BinDataRecord는 완전히 파싱 / Fully parse BinDataRecord let bin_data_record = BinDataRecord::parse(record_data).map_err(|e| HwpError::from(e))?; doc_info.bin_data.push(bin_data_record); } } HwpTag::FACE_NAME => { if header.level == 1 { // FaceName은 완전히 파싱 / Fully parse FaceName let face_name = FaceName::parse(record_data).map_err(|e| HwpError::from(e))?; doc_info.face_names.push(face_name); } } HwpTag::BORDER_FILL => { if header.level == 1 { // BorderFill은 완전히 파싱 / Fully parse BorderFill let border_fill = BorderFill::parse(record_data).map_err(|e| HwpError::from(e))?; doc_info.border_fill.push(border_fill); } } HwpTag::CHAR_SHAPE => { if header.level == 1 { // CharShape는 완전히 파싱 / Fully parse CharShape let char_shape = CharShape::parse(record_data, file_header.version) .map_err(|e| HwpError::from(e))?; doc_info.char_shapes.push(char_shape); } } HwpTag::TAB_DEF => { if header.level == 1 { // TabDef는 완전히 파싱 / Fully parse TabDef let tab_def = TabDef::parse(record_data).map_err(|e| HwpError::from(e))?; doc_info.tab_defs.push(tab_def); } } HwpTag::NUMBERING => { if header.level == 1 { // Numbering은 완전히 파싱 / Fully parse Numbering let numbering = Numbering::parse(record_data, file_header.version) .map_err(|e| HwpError::from(e))?; doc_info.numbering.push(numbering); } } HwpTag::BULLET => { if header.level == 1 { // Bullet은 완전히 파싱 / Fully parse Bullet let bullet = Bullet::parse(record_data).map_err(|e| HwpError::from(e))?; doc_info.bullets.push(bullet); } } HwpTag::PARA_SHAPE => { if header.level == 1 { // ParaShape은 완전히 파싱 / Fully parse ParaShape let para_shape = ParaShape::parse(record_data, file_header.version) .map_err(|e| HwpError::from(e))?; doc_info.para_shapes.push(para_shape); } } HwpTag::STYLE => { if header.level == 1 { let style = Style::parse(record_data).map_err(|e| HwpError::from(e))?; doc_info.styles.push(style); } } HwpTag::DOC_DATA => { if header.level == 0 { // 문서 임의의 데이터 파싱 / Parse document arbitrary data let doc_data = DocData::parse(record_data).map_err(|e| HwpError::from(e))?; doc_info.doc_data.push(doc_data); } } HwpTag::DISTRIBUTE_DOC_DATA => { if header.level == 0 { // 배포용 문서 데이터 파싱 / Parse distribution document data let distribute_doc_data = DistributeDocData::parse(record_data).map_err(|e| HwpError::from(e))?; doc_info.distribute_doc_data = Some(distribute_doc_data); } } HwpTag::COMPATIBLE_DOCUMENT => { if header.level == 0 { // 호환 문서 파싱 / Parse compatible document let compatible_document = CompatibleDocument::parse(record_data) .map_err(|e| HwpError::from(e))?; doc_info.compatible_document = Some(compatible_document); } } HwpTag::LAYOUT_COMPATIBILITY => { if header.level == 1 { // 레이아웃 호환성 파싱 / Parse layout compatibility let layout_compatibility = LayoutCompatibility::parse(record_data) .map_err(|e| HwpError::from(e))?; doc_info.layout_compatibility = Some(layout_compatibility); } } HwpTag::TRACKCHANGE => { if header.level == 1 { // 변경 추적 정보 파싱 / Parse track change information let track_change = TrackChange::parse(record_data).map_err(|e| HwpError::from(e))?; doc_info.track_change = Some(track_change); } } HwpTag::MEMO_SHAPE => { if header.level == 1 { // 메모 모양 파싱 / Parse memo shape let memo_shape = MemoShape::parse(record_data).map_err(|e| HwpError::from(e))?; doc_info.memo_shapes.push(memo_shape); } } HwpTag::FORBIDDEN_CHAR => { if header.level == 0 { // 금칙처리 문자 파싱 / Parse forbidden character let forbidden_char = ForbiddenChar::parse(record_data).map_err(|e| HwpError::from(e))?; doc_info.forbidden_chars.push(forbidden_char); } } HwpTag::TRACK_CHANGE => { if header.level == 1 { // 변경 추적 내용 및 모양 파싱 / Parse track change content and shape let track_change_content = TrackChangeContent::parse(record_data) .map_err(|e| HwpError::from(e))?; doc_info.track_change_contents.push(track_change_content); } } HwpTag::TRACK_CHANGE_AUTHOR => { if header.level == 1 { // 변경 추적 작성자 파싱 / Parse track change author let track_change_author = TrackChangeAuthor::parse(record_data).map_err(|e| HwpError::from(e))?; doc_info.track_change_authors.push(track_change_author); } } // 기타 태그는 무시 (나중에 구현 가능) / Other tags are ignored (can be implemented later) _ => { // 알 수 없는 태그는 무시하고 계속 진행 / Unknown tags are ignored and continue } } } Ok(doc_info) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/style.rs

crates/hwp-core/src/document/docinfo/style.rs

/// Style 구조체 / Style structure /// /// 스펙 문서 매핑: 표 47 - 스타일 / Spec mapping: Table 47 - Style /// Tag ID: HWPTAG_STYLE /// 전체 길이: 가변 (12 + 2×len1 + 2×len2 바이트) / Total length: variable (12 + 2×len1 + 2×len2 bytes) use crate::error::HwpError; use crate::types::{decode_utf16le, BYTE, INT16, UINT16, WORD}; use serde::{Deserialize, Serialize}; /// 스타일 종류 / Style type #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum StyleType { /// 문단 스타일 / Paragraph style Paragraph = 0, /// 글자 스타일 / Character style Character = 1, } impl StyleType { fn from_bits(bits: u8) -> Self { match bits & 0x07 { 1 => StyleType::Character, _ => StyleType::Paragraph, } } } /// Style 구조체 / Style structure #[derive(Debug, Clone, Serialize, Deserialize)] pub struct Style { /// 로컬/한글 스타일 이름 / Local/Korean style name pub local_name: String, /// 영문 스타일 이름 / English style name pub english_name: String, /// 속성 (표 48 참조, bit 0-2: 스타일 종류) / Attributes (See Table 48, bit 0-2: style type) pub style_type: StyleType, /// 다음 스타일 ID 참조 값 / Next style ID reference value pub next_style_id: BYTE, /// 언어 ID (표 48 참조) / Language ID (See Table 48) pub lang_id: INT16, /// 문단 모양 ID 참조 값 (스타일 종류가 문단인 경우 필수) / Paragraph shape ID reference (required if style type is paragraph) pub para_shape_id: Option<UINT16>, /// 글자 모양 ID (스타일 종류가 글자인 경우 필수) / Character shape ID (required if style type is character) pub char_shape_id: Option<UINT16>, } impl Style { /// Style을 바이트 배열에서 파싱합니다. / Parse Style from byte array. /// /// # Arguments /// * `data` - Style 레코드 데이터 / Style record data /// /// # Returns /// 파싱된 Style 구조체 / Parsed Style structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // 최소 12바이트 필요 (고정 필드들) / Need at least 12 bytes for fixed fields if data.len() < 12 { return Err(HwpError::insufficient_data("Style", 12, data.len())); } let mut offset = 0; // WORD 길이(len1) / WORD length (len1) let len1 = WORD::from_le_bytes([data[offset], data[offset + 1]]) as usize; offset += 2; // WCHAR array[len1] 로컬/한글 스타일 이름 / WCHAR array[len1] local/Korean style name if offset + (len1 * 2) > data.len() { return Err(HwpError::InsufficientData { field: format!("Style local name at offset {}", offset), expected: offset + (len1 * 2), actual: data.len(), }); } let local_name_bytes = &data[offset..offset + (len1 * 2)]; let local_name = decode_utf16le(local_name_bytes) .map_err(|e| HwpError::EncodingError { reason: format!("Failed to decode local name: {}", e), })?; offset += len1 * 2; // WORD 길이(len2) / WORD length (len2) if offset + 2 > data.len() { return Err(HwpError::insufficient_data( "Style English name length", 2, data.len() - offset, )); } let len2 = WORD::from_le_bytes([data[offset], data[offset + 1]]) as usize; offset += 2; // WCHAR array[len2] 영문 스타일 이름 / WCHAR array[len2] English style name if offset + (len2 * 2) > data.len() { return Err(HwpError::InsufficientData { field: format!("Style English name at offset {}", offset), expected: offset + (len2 * 2), actual: data.len(), }); } let english_name_bytes = &data[offset..offset + (len2 * 2)]; let english_name = decode_utf16le(english_name_bytes) .map_err(|e| HwpError::EncodingError { reason: format!("Failed to decode English name: {}", e), })?; offset += len2 * 2; // BYTE 속성 (표 48 참조, bit 0-2: 스타일 종류) / BYTE attributes (See Table 48, bit 0-2: style type) if offset + 1 > data.len() { return Err(HwpError::insufficient_data( "Style attributes", 1, data.len() - offset, )); } let attributes = data[offset]; offset += 1; let style_type = StyleType::from_bits(attributes); // BYTE 다음 스타일 ID 참조 값 / BYTE next style ID reference value if offset + 1 > data.len() { return Err(HwpError::insufficient_data( "Style next style ID", 1, data.len() - offset, )); } let next_style_id = data[offset]; offset += 1; // INT16 언어 ID (표 48 참조) / INT16 language ID (See Table 48) if offset + 2 > data.len() { return Err(HwpError::insufficient_data( "Style language ID", 2, data.len() - offset, )); } let lang_id = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT16 문단 모양 ID 참조 값 (스타일 종류가 문단인 경우 필수) / UINT16 paragraph shape ID reference (required if style type is paragraph) if offset + 2 > data.len() { return Err(HwpError::insufficient_data( "Style paragraph shape ID", 2, data.len() - offset, )); } let para_shape_id_value = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let para_shape_id = if style_type == StyleType::Paragraph { Some(para_shape_id_value) } else { None }; // UINT16 글자 모양 ID (스타일 종류가 글자인 경우 필수) / UINT16 character shape ID (required if style type is character) if offset + 2 > data.len() { return Err(HwpError::insufficient_data( "Style character shape ID", 2, data.len() - offset, )); } let char_shape_id_value = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let char_shape_id = if style_type == StyleType::Character { Some(char_shape_id_value) } else { None }; Ok(Style { local_name, english_name, style_type, next_style_id, lang_id, para_shape_id, char_shape_id, }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/numbering.rs

crates/hwp-core/src/document/docinfo/numbering.rs

/// Numbering 구조체 / Numbering structure /// /// 스펙 문서 매핑: 표 38 - 문단 번호 / Spec mapping: Table 38 - Paragraph numbering /// Tag ID: HWPTAG_NUMBERING /// 전체 길이: 가변 / Total length: variable use crate::error::HwpError; use crate::types::{decode_utf16le, HWPUNIT16, UINT16, UINT32, WORD}; use serde::{Deserialize, Serialize}; /// 문단 머리 정보 속성 / Paragraph header information attributes #[derive(Debug, Clone, Serialize, Deserialize)] pub struct NumberingHeaderAttributes { /// 문단의 정렬 종류 / Paragraph alignment type pub align_type: ParagraphAlignType, /// 인스턴스 유사 여부 (bit 2) / Instance-like flag (bit 2) pub instance_like: bool, /// 자동 내어 쓰기 여부 / Auto outdent flag pub auto_outdent: bool, /// 수준별 본문과의 거리 종류 / Distance type from body text by level pub distance_type: DistanceType, } /// 문단 정렬 종류 / Paragraph alignment type #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum ParagraphAlignType { /// 왼쪽 / Left Left = 0, /// 가운데 / Center Center = 1, /// 오른쪽 / Right Right = 2, } impl ParagraphAlignType { fn from_bits(bits: u32) -> Self { match bits & 0x00000003 { 1 => ParagraphAlignType::Center, 2 => ParagraphAlignType::Right, _ => ParagraphAlignType::Left, } } } /// 수준별 본문과의 거리 종류 / Distance type from body text by level #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum DistanceType { /// 글자 크기에 대한 상대 비율 / Relative ratio to font size Ratio = 0, /// 값 / Value Value = 1, } impl DistanceType { fn from_bit(bit: bool) -> Self { if bit { DistanceType::Value } else { DistanceType::Ratio } } } /// 문단 머리 정보 (수준별) / Paragraph header information (per level) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct NumberingLevelInfo { /// 속성 (표 40) / Attributes (Table 40) pub attributes: NumberingHeaderAttributes, /// 너비 보정값 / Width correction value pub width: HWPUNIT16, /// 본문과의 거리 / Distance from body text pub distance: HWPUNIT16, /// 글자 모양 아이디 참조 / Character shape ID reference pub char_shape_id: UINT32, /// 번호 형식 길이 / Number format length pub format_length: WORD, /// 번호 형식 문자열 / Number format string pub format_string: String, /// 시작 번호 / Start number pub start_number: UINT16, /// 수준별 시작번호 (5.0.2.5 이상, 옵션) / Level-specific start number (5.0.2.5+, optional) pub level_start_number: Option<UINT32>, } /// Numbering 구조체 / Numbering structure #[derive(Debug, Clone, Serialize, Deserialize)] pub struct Numbering { /// 수준별 문단 머리 정보 (7개 수준, 1~7) / Level-specific paragraph header information (7 levels, 1~7) pub levels: Vec<NumberingLevelInfo>, /// 확장 번호 형식 (3개 수준, 8~10, 옵션) / Extended number format (3 levels, 8~10, optional) pub extended_levels: Vec<ExtendedNumberingLevel>, } /// 확장 번호 형식 (수준 8~10) / Extended number format (levels 8~10) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ExtendedNumberingLevel { /// 번호 형식 길이 / Number format length pub format_length: WORD, /// 번호 형식 문자열 / Number format string pub format_string: String, } impl Numbering { /// Numbering을 바이트 배열에서 파싱합니다. / Parse Numbering from byte array. /// /// # Arguments /// * `data` - Numbering 레코드 데이터 / Numbering record data /// * `version` - HWP 파일 버전 (5.0.2.5 이상에서 수준별 시작번호 지원) / HWP file version (level-specific start numbers supported in 5.0.2.5+) /// /// # Returns /// 파싱된 Numbering 구조체 / Parsed Numbering structure pub fn parse(data: &[u8], version: u32) -> Result<Self, HwpError> { let mut offset = 0; let mut levels = Vec::new(); // 7개 수준 파싱 (1~7) / Parse 7 levels (1~7) for _ in 0..7 { // 데이터가 부족하면 기본값으로 채우고 종료 / Fill with defaults and exit if insufficient data if offset + 12 > data.len() { // 최소 12바이트 (속성 4 + 너비 2 + 거리 2 + 글자모양ID 4) 필요 / Need at least 12 bytes break; } // UINT 속성 (표 40) / UINT attributes (Table 40) let attr_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let attributes = NumberingHeaderAttributes { align_type: ParagraphAlignType::from_bits(attr_value), instance_like: (attr_value & 0x00000004) != 0, auto_outdent: (attr_value & 0x00000008) != 0, distance_type: DistanceType::from_bit((attr_value & 0x00000010) != 0), }; // HWPUNIT16 너비 보정값 / HWPUNIT16 width correction value let width = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // HWPUNIT16 본문과의 거리 / HWPUNIT16 distance from body text let distance = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT 글자 모양 아이디 참조 / UINT character shape ID reference let char_shape_id = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // WORD 번호 형식 길이 / WORD number format length let (format_length, format_string) = if offset + 2 <= data.len() { let len = WORD::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // WCHAR array[format_length] 번호 형식 문자열 / WCHAR array[format_length] number format string let format_bytes = len as usize * 2; if offset + format_bytes <= data.len() { let str = decode_utf16le(&data[offset..offset + format_bytes]) .map_err(|e| HwpError::EncodingError { reason: format!("Failed to decode numbering format: {}", e), })?; offset += format_bytes; (len, str) } else { // 데이터가 부족하면 빈 문자열 / Empty string if insufficient data (0, String::new()) } } else { // 데이터가 부족하면 기본값 사용 / Use default if insufficient data (0, String::new()) }; // UINT16 시작 번호 / UINT16 start number let start_number = if offset + 2 <= data.len() { let value = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; value } else { 0 }; // UINT 수준별 시작번호 (5.0.2.5 이상, 옵션) / UINT level-specific start number (5.0.2.5+, optional) let level_start_number = if version >= 0x00020500 && offset + 4 <= data.len() { let value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; Some(value) } else { None }; levels.push(NumberingLevelInfo { attributes, width, distance, char_shape_id, format_length, format_string, start_number, level_start_number, }); } // 확장 번호 형식 파싱 (3개 수준, 8~10) / Parse extended number format (3 levels, 8~10) let mut extended_levels = Vec::new(); for _ in 0..3 { if offset + 2 > data.len() { // 확장 레벨이 없을 수 있음 / Extended levels may not exist break; } // WORD 확장 번호 형식 길이 / WORD extended number format length let format_length = WORD::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // WCHAR array[format_length] 확장 번호 형식 문자열 / WCHAR array[format_length] extended number format string let format_bytes = format_length as usize * 2; if offset + format_bytes > data.len() { // 확장 레벨 데이터가 불완전할 수 있음 / Extended level data may be incomplete break; } let format_string = decode_utf16le(&data[offset..offset + format_bytes]) .map_err(|e| HwpError::EncodingError { reason: format!("Failed to decode extended numbering format: {}", e), })?; offset += format_bytes; extended_levels.push(ExtendedNumberingLevel { format_length, format_string, }); } Ok(Numbering { levels, extended_levels, }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/constants.rs

crates/hwp-core/src/document/docinfo/constants.rs

/// DocInfo 태그 상수 정의 / DocInfo tag constants definition /// /// 스펙 문서 매핑: 표 13 - 문서 정보의 데이터 레코드 / Spec mapping: Table 13 - Document information data records use crate::document::constants::HWPTAG_BEGIN; /// DocInfo 태그 상수 / DocInfo tag constants pub struct HwpTag; impl HwpTag { /// 문서 속성 / Document properties pub const DOCUMENT_PROPERTIES: u16 = HWPTAG_BEGIN; /// 아이디 매핑 헤더 / ID mappings header pub const ID_MAPPINGS: u16 = HWPTAG_BEGIN + 1; /// 바이너리 데이터 / Binary data pub const BIN_DATA: u16 = HWPTAG_BEGIN + 2; /// 글꼴 (Typeface Name) / Face name (Typeface Name) pub const FACE_NAME: u16 = HWPTAG_BEGIN + 3; /// 테두리/배경 / Border/fill pub const BORDER_FILL: u16 = HWPTAG_BEGIN + 4; /// 글자 모양 / Character shape pub const CHAR_SHAPE: u16 = HWPTAG_BEGIN + 5; /// 탭 정의 / Tab definition pub const TAB_DEF: u16 = HWPTAG_BEGIN + 6; /// 번호 정의 / Numbering definition pub const NUMBERING: u16 = HWPTAG_BEGIN + 7; /// 불릿 정의 / Bullet definition pub const BULLET: u16 = HWPTAG_BEGIN + 8; /// 문단 모양 / Paragraph shape pub const PARA_SHAPE: u16 = HWPTAG_BEGIN + 9; /// 스타일 / Style pub const STYLE: u16 = HWPTAG_BEGIN + 10; /// 문서의 임의의 데이터 / Document arbitrary data pub const DOC_DATA: u16 = HWPTAG_BEGIN + 11; /// 배포용 문서 데이터 / Distribution document data pub const DISTRIBUTE_DOC_DATA: u16 = HWPTAG_BEGIN + 12; /// 예약 / Reserved pub const RESERVED: u16 = HWPTAG_BEGIN + 13; /// 호환 문서 / Compatible document pub const COMPATIBLE_DOCUMENT: u16 = HWPTAG_BEGIN + 14; /// 레이아웃 호환성 / Layout compatibility pub const LAYOUT_COMPATIBILITY: u16 = HWPTAG_BEGIN + 15; /// 변경 추적 정보 / Track change information pub const TRACKCHANGE: u16 = HWPTAG_BEGIN + 16; /// 메모 모양 / Memo shape pub const MEMO_SHAPE: u16 = HWPTAG_BEGIN + 76; /// 금칙처리 문자 / Forbidden character pub const FORBIDDEN_CHAR: u16 = HWPTAG_BEGIN + 78; /// 변경 추적 내용 및 모양 / Track change content and shape pub const TRACK_CHANGE: u16 = HWPTAG_BEGIN + 80; /// 변경 추적 작성자 / Track change author pub const TRACK_CHANGE_AUTHOR: u16 = HWPTAG_BEGIN + 81; }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/doc_data.rs

crates/hwp-core/src/document/docinfo/doc_data.rs

/// DocData 구조체 / DocData structure /// /// 스펙 문서 매핑: 표 49 - 문서 임의의 데이터 / Spec mapping: Table 49 - Document arbitrary data use crate::error::HwpError; use crate::types::{decode_utf16le, INT16, INT32, INT8, UINT16, UINT32, UINT8, WORD}; use serde::{Deserialize, Serialize}; /// 문서 임의의 데이터 (표 49) / Document arbitrary data (Table 49) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct DocData { /// 파라미터 셋 (표 50 참조) / Parameter set (see Table 50) pub parameter_set: ParameterSet, } /// 파라미터 셋 (표 50) / Parameter set (Table 50) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ParameterSet { /// 파라미터 셋 ID / Parameter set ID pub set_id: WORD, /// 파라미터 셋에 존재하는 아이템 개수 / Number of items in parameter set pub item_count: INT16, /// 파라미터 아이템 리스트 / Parameter item list pub items: Vec<ParameterItem>, } /// 파라미터 아이템 (표 51) / Parameter item (Table 51) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ParameterItem { /// 파라미터 아이템 ID / Parameter item ID pub id: WORD, /// 파라미터 아이템 종류 (표 52 참조) / Parameter item type (see Table 52) pub item_type: ParameterItemType, /// 파라미터 아이템 데이터 / Parameter item data pub data: ParameterItemData, } /// 파라미터 아이템 종류 (표 52) / Parameter item type (Table 52) #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum ParameterItemType { /// NULL / NULL Null, /// 문자열 / String Bstr, /// INT8 / INT8 I1, /// INT16 / INT16 I2, /// INT32 / INT32 I4, /// INT / INT I, /// UINT8 / UINT8 Ui1, /// UINT16 / UINT16 Ui2, /// UINT32 / UINT32 Ui4, /// UINT / UINT Ui, /// 파라미터 셋 / Parameter set Set, /// 파라미터 셋 배열 / Parameter set array Array, /// 바이너리 데이터 ID / Binary data ID Bindata, } /// 파라미터 아이템 데이터 / Parameter item data #[derive(Debug, Clone, Serialize, Deserialize)] #[serde(tag = "type", rename_all = "snake_case")] pub enum ParameterItemData { /// NULL / NULL Null, /// 문자열 / String Bstr(String), /// INT8 / INT8 I1(INT8), /// INT16 / INT16 I2(INT16), /// INT32 / INT32 I4(INT32), /// INT / INT I(INT8), /// UINT8 / UINT8 Ui1(UINT8), /// UINT16 / UINT16 Ui2(UINT16), /// UINT32 / UINT32 Ui4(UINT32), /// UINT / UINT Ui(UINT8), /// 파라미터 셋 / Parameter set Set(ParameterSet), /// 파라미터 셋 배열 / Parameter set array Array(Vec<ParameterSet>), /// 바이너리 데이터 ID / Binary data ID Bindata(UINT16), } impl DocData { /// DocData를 바이트 배열에서 파싱합니다. / Parse DocData from byte array. /// /// # Arguments /// * `data` - DocData 데이터 / DocData data /// /// # Returns /// 파싱된 DocData 구조체 / Parsed DocData structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.is_empty() { return Err(HwpError::InsufficientData { field: "DocData data".to_string(), expected: 1, actual: 0, }); } // 파라미터 셋 파싱 (표 50) / Parse parameter set (Table 50) let parameter_set = ParameterSet::parse(data)?; Ok(DocData { parameter_set }) } } impl ParameterSet { /// ParameterSet을 바이트 배열에서 파싱합니다. / Parse ParameterSet from byte array. /// /// # Arguments /// * `data` - ParameterSet 데이터 / ParameterSet data /// /// # Returns /// 파싱된 ParameterSet 구조체 / Parsed ParameterSet structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 4 { return Err(HwpError::insufficient_data("ParameterSet", 4, data.len())); } let mut offset = 0; // WORD 파라미터 셋 ID / WORD parameter set ID let set_id = WORD::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // INT16 파라미터 셋에 존재하는 아이템 개수 / INT16 number of items in parameter set let item_count = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // 파라미터 아이템 파싱 / Parse parameter items let mut items = Vec::new(); let mut current_offset = offset; for _ in 0..item_count { if current_offset >= data.len() { break; // 데이터가 부족할 수 있음 / Data may be insufficient } match ParameterItem::parse(&data[current_offset..]) { Ok((item, item_size)) => { items.push(item); current_offset += item_size; } Err(e) => { // 파싱 실패 시 경고하고 계속 진행 / Warn and continue on parse failure // 알 수 없는 타입의 경우 ParameterItem::parse에서 이미 처리하므로 여기 도달하지 않아야 함 // Continue on parse error with warning // Unknown types should be handled in ParameterItem::parse, so this shouldn't be reached #[cfg(debug_assertions)] eprintln!("Failed to parse parameter item: {}", e); // 에러가 발생한 경우 최소한 id와 item_type(4바이트)는 건너뛰고 계속 진행 // On error, skip at least id and item_type (4 bytes) and continue if current_offset + 4 <= data.len() { current_offset += 4; } else { break; } } } } Ok(ParameterSet { set_id, item_count, items, }) } } impl ParameterItem { /// ParameterItem을 바이트 배열에서 파싱합니다. / Parse ParameterItem from byte array. /// /// # Arguments /// * `data` - ParameterItem 데이터 / ParameterItem data /// /// # Returns /// 파싱된 ParameterItem과 사용된 바이트 수 / Parsed ParameterItem and bytes consumed pub fn parse(data: &[u8]) -> Result<(Self, usize), HwpError> { if data.len() < 4 { return Err(HwpError::insufficient_data("ParameterItem", 4, data.len())); } let mut offset = 0; // WORD 파라미터 아이템 ID / WORD parameter item ID let id = WORD::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // WORD 파라미터 아이템 종류 (표 52 참조) / WORD parameter item type (see Table 52) let item_type_value = WORD::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let item_type = match item_type_value { 0 => ParameterItemType::Null, 1 => ParameterItemType::Bstr, 2 => ParameterItemType::I1, 3 => ParameterItemType::I2, 4 => ParameterItemType::I4, 5 => ParameterItemType::I, 6 => ParameterItemType::Ui1, 7 => ParameterItemType::Ui2, 8 => ParameterItemType::Ui4, 9 => ParameterItemType::Ui, 0x8000 => ParameterItemType::Set, 0x8001 => ParameterItemType::Array, 0x8002 => ParameterItemType::Bindata, _ => { // 스펙 문서(표 52)에 명시되지 않은 알 수 없는 타입 // Unknown type not specified in spec (Table 52) // // 이유: 스펙 문서 표 52에는 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0x8000, 0x8001, 0x8002만 정의되어 있음 // Reason: Spec document Table 52 only defines 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0x8000, 0x8001, 0x8002 // // 실제 파일에서 발견된 타입(예: 519 = 0x0207)은 스펙 문서에 없으므로 // 데이터 크기를 알 수 없어 파싱할 수 없음 // Types found in actual files (e.g., 519 = 0x0207) are not in spec, // so we cannot determine data size and cannot parse // // 별도 처리: 알 수 없는 타입의 경우 id와 item_type만 저장하고 데이터는 건너뜀 // Special handling: For unknown types, only save id and item_type, skip data #[cfg(debug_assertions)] eprintln!( "Warning: Unknown parameter item type: {} (0x{:04x}) - not in spec Table 52, skipping data", item_type_value, item_type_value ); // 알 수 없는 타입의 경우 데이터 크기를 알 수 없으므로, id와 item_type만 반환 // For unknown types, we can't determine data size, so return only id and item_type return Ok(( ParameterItem { id, item_type: ParameterItemType::Null, // 알 수 없는 타입이므로 Null로 표시 / Mark as Null for unknown type data: ParameterItemData::Null, }, 4, // id(2) + item_type(2)만 사용 / Only id(2) + item_type(2) consumed )); } }; // 파라미터 아이템 데이터 파싱 / Parse parameter item data let (data_value, data_size) = parse_parameter_item_data(&data[offset..], item_type) .map_err(|e| HwpError::from(e))?; offset += data_size; Ok(( ParameterItem { id, item_type, data: data_value, }, offset, )) } } /// 파라미터 아이템 데이터 파싱 / Parse parameter item data fn parse_parameter_item_data( data: &[u8], item_type: ParameterItemType, ) -> Result<(ParameterItemData, usize), HwpError> { match item_type { ParameterItemType::Null => { // PIT_NULL: UINT | NULL // 스펙 문서: "UINT | NULL" - NULL이므로 데이터 없음 // Spec: "UINT | NULL" - no data for NULL Ok((ParameterItemData::Null, 0)) } ParameterItemType::Bstr => { // PIT_BSTR: WORD 문자열 길이(slen) + WCHAR array[len] // 스펙 문서: "WORD | 문자열 길이(slen)" + "WCHAR array[len]" // Spec: "WORD | string length(slen)" + "WCHAR array[len]" if data.len() < 2 { return Err(HwpError::insufficient_data("BSTR length", 2, data.len())); } let string_len = WORD::from_le_bytes([data[0], data[1]]) as usize; let total_size = 2 + (string_len * 2); // WORD(2) + WCHAR array if data.len() < total_size { return Err(HwpError::InsufficientData { field: "BSTR data".to_string(), expected: total_size, actual: data.len(), }); } let string_bytes = &data[2..total_size]; let string = decode_utf16le(string_bytes) .map_err(|e| HwpError::EncodingError { reason: format!("Failed to decode BSTR: {}", e), })?; Ok((ParameterItemData::Bstr(string), total_size)) } ParameterItemType::I1 => { // PIT_I1: INT8 / PIT_I1: INT8 if data.len() < 1 { return Err(HwpError::insufficient_data("I1", 1, data.len())); } Ok((ParameterItemData::I1(INT8::from_le_bytes([data[0]])), 1)) } ParameterItemType::I2 => { // PIT_I2: INT16 / PIT_I2: INT16 if data.len() < 2 { return Err(HwpError::insufficient_data("I2", 2, data.len())); } Ok(( ParameterItemData::I2(INT16::from_le_bytes([data[0], data[1]])), 2, )) } ParameterItemType::I4 => { // PIT_I4: INT32 / PIT_I4: INT32 if data.len() < 4 { return Err(HwpError::insufficient_data("I4", 4, data.len())); } Ok(( ParameterItemData::I4(INT32::from_le_bytes([data[0], data[1], data[2], data[3]])), 4, )) } ParameterItemType::I => { // PIT_I: INT8 / PIT_I: INT8 if data.len() < 1 { return Err(HwpError::insufficient_data("I", 1, data.len())); } Ok((ParameterItemData::I(INT8::from_le_bytes([data[0]])), 1)) } ParameterItemType::Ui1 => { // PIT_UI1: UINT8 / PIT_UI1: UINT8 if data.len() < 1 { return Err(HwpError::insufficient_data("UI1", 1, data.len())); } Ok((ParameterItemData::Ui1(UINT8::from_le_bytes([data[0]])), 1)) } ParameterItemType::Ui2 => { // PIT_UI2: UINT16 / PIT_UI2: UINT16 if data.len() < 2 { return Err(HwpError::insufficient_data("UI2", 2, data.len())); } Ok(( ParameterItemData::Ui2(UINT16::from_le_bytes([data[0], data[1]])), 2, )) } ParameterItemType::Ui4 => { // PIT_UI4: UINT32 / PIT_UI4: UINT32 if data.len() < 4 { return Err(HwpError::insufficient_data("UI4", 4, data.len())); } Ok(( ParameterItemData::Ui4(UINT32::from_le_bytes([data[0], data[1], data[2], data[3]])), 4, )) } ParameterItemType::Ui => { // PIT_UI: UINT8 / PIT_UI: UINT8 if data.len() < 1 { return Err(HwpError::insufficient_data("UI", 1, data.len())); } Ok((ParameterItemData::Ui(UINT8::from_le_bytes([data[0]])), 1)) } ParameterItemType::Set => { // PIT_SET: Parameter Set / PIT_SET: Parameter Set // 재귀적으로 파싱 / Parse recursively let parameter_set = ParameterSet::parse(data) .map_err(|e| HwpError::from(e))?; // 사용된 바이트 수 계산 (대략적으로) / Calculate bytes consumed (approximately) let size = 4 + parameter_set.items.iter().map(|_| 4).sum::<usize>(); // 최소 크기 / Minimum size Ok((ParameterItemData::Set(parameter_set), size)) } ParameterItemType::Array => { // PIT_ARRAY: ParameterArray / PIT_ARRAY: ParameterArray // INT16 파라미터 셋 개수 + Parameter Set 배열 / INT16 parameter set count + Parameter Set array if data.len() < 2 { return Err(HwpError::insufficient_data("Array count", 2, data.len())); } let array_count = INT16::from_le_bytes([data[0], data[1]]) as usize; let mut offset = 2; let mut parameter_sets = Vec::new(); for _ in 0..array_count { if offset >= data.len() { break; } match ParameterSet::parse(&data[offset..]) { Ok(set) => { // 대략적인 크기 계산 / Approximate size calculation let set_size = 4 + set.items.len() * 4; offset += set_size; parameter_sets.push(set); } Err(e) => { #[cfg(debug_assertions)] eprintln!("Failed to parse parameter set in array: {}", e); break; } } } Ok((ParameterItemData::Array(parameter_sets), offset)) } ParameterItemType::Bindata => { // PIT_BINDATA: UINT16 바이너리 데이터 ID / PIT_BINDATA: UINT16 binary data ID if data.len() < 2 { return Err(HwpError::insufficient_data("Bindata", 2, data.len())); } Ok(( ParameterItemData::Bindata(UINT16::from_le_bytes([data[0], data[1]])), 2, )) } } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/para_shape.rs

crates/hwp-core/src/document/docinfo/para_shape.rs

/// ParaShape 구조체 / ParaShape structure /// /// 스펙 문서 매핑: 표 43 - 문단 모양 / Spec mapping: Table 43 - Paragraph shape /// Tag ID: HWPTAG_PARA_SHAPE /// 전체 길이: 54바이트 / Total length: 54 bytes use crate::error::HwpError; use crate::types::{INT16, INT32, UINT16, UINT32, UINT8}; use serde::{Deserialize, Serialize}; /// 문단 모양 속성1 / Paragraph shape attributes 1 #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ParaShapeAttributes1 { /// 줄 간격 종류(한글 2007 이하 버전) / Line spacing type (HWP 2007 and below) pub line_spacing_type_old: LineSpacingTypeOld, /// 정렬 방법 / Alignment method pub align: ParagraphAlignment, /// 줄 나눔 기준 영문 단위 / Line break unit for English pub line_divide_en: LineDivideUnit, /// 줄 나눔 기준 한글 단위 / Line break unit for Korean pub line_divide_ko: LineDivideUnit, /// 편집 용지의 줄 격자 사용 여부 / Use line grid of editing paper pub use_line_grid: bool, /// 최소 공백 값(0%~75%) / Minimum blank value (0%~75%) pub blank_min_value: UINT8, /// 외톨이 줄 보호 / Protect orphan line pub protect_orphan_line: bool, /// 다음 문단과 함께 / With next paragraph pub with_next_paragraph: bool, /// 문단 보호 / Protect paragraph pub protect_paragraph: bool, /// 문단 앞에서 항상 쪽 나눔 / Always page break before paragraph pub always_page_break_before: bool, /// 세로 정렬 / Vertical alignment pub vertical_align: VerticalAlignment, /// 글꼴에 맞는 줄 높이 / Line height matches font pub line_height_matches_font: bool, /// 문단 머리 모양 종류 / Paragraph header shape type pub header_shape_type: HeaderShapeType, /// 문단 수준(1~7) / Paragraph level (1~7) pub paragraph_level: UINT8, /// 문단 테두리 연결 / Connect paragraph border pub connect_border: bool, /// 문단 여백 무시 / Ignore paragraph margin pub ignore_margin: bool, /// 문단 꼬리 모양 / Paragraph tail shape pub tail_shape: bool, } /// 줄 간격 종류(한글 2007 이하 버전) / Line spacing type (HWP 2007 and below) #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum LineSpacingTypeOld { /// 글자에 따라(%) / By character (%) ByCharacter = 0, /// 고정값 / Fixed value Fixed = 1, /// 여백만 지정 / Margin only MarginOnly = 2, } impl LineSpacingTypeOld { fn from_bits(bits: u32) -> Self { match bits & 0x00000003 { 1 => LineSpacingTypeOld::Fixed, 2 => LineSpacingTypeOld::MarginOnly, _ => LineSpacingTypeOld::ByCharacter, } } } /// 정렬 방법 / Alignment method #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum ParagraphAlignment { /// 양쪽 정렬 / Justify Justify = 0, /// 왼쪽 / Left Left = 1, /// 오른쪽 / Right Right = 2, /// 가운데 / Center Center = 3, /// 배분 / Distribute Distribute = 4, /// 나눔 / Divide Divide = 5, } impl ParagraphAlignment { fn from_bits(bits: u32) -> Self { match (bits >> 2) & 0x00000007 { 1 => ParagraphAlignment::Left, 2 => ParagraphAlignment::Right, 3 => ParagraphAlignment::Center, 4 => ParagraphAlignment::Distribute, 5 => ParagraphAlignment::Divide, _ => ParagraphAlignment::Justify, } } } /// 줄 나눔 기준 단위 / Line break unit #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum LineDivideUnit { /// 단어 / Word Word = 0, /// 하이픈 / Hyphen Hyphen = 1, /// 글자 / Character Character = 2, } impl LineDivideUnit { fn from_bits_en(bits: u32) -> Self { match (bits >> 5) & 0x00000003 { 1 => LineDivideUnit::Hyphen, 2 => LineDivideUnit::Character, _ => LineDivideUnit::Word, } } fn from_bit_ko(bit: bool) -> Self { if bit { LineDivideUnit::Character } else { LineDivideUnit::Word } } } /// 세로 정렬 / Vertical alignment #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum VerticalAlignment { /// 글꼴 기준선 / Font baseline Baseline = 0, /// 위 / Top Top = 1, /// 가운데 / Center Center = 2, /// 아래 / Bottom Bottom = 3, } impl VerticalAlignment { fn from_bits(bits: u32) -> Self { match (bits >> 20) & 0x00000003 { 1 => VerticalAlignment::Top, 2 => VerticalAlignment::Center, 3 => VerticalAlignment::Bottom, _ => VerticalAlignment::Baseline, } } } /// 문단 머리 모양 종류 / Paragraph header shape type #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum HeaderShapeType { /// 없음 / None None = 0, /// 개요 / Outline Outline = 1, /// 번호 / Number Number = 2, /// 글머리표 / Bullet Bullet = 3, } impl HeaderShapeType { fn from_bits(bits: u32) -> Self { match (bits >> 23) & 0x00000003 { 1 => HeaderShapeType::Outline, 2 => HeaderShapeType::Number, 3 => HeaderShapeType::Bullet, _ => HeaderShapeType::None, } } } /// 문단 모양 속성2 / Paragraph shape attributes 2 #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ParaShapeAttributes2 { /// 한 줄 입력 / Single line input pub single_line_input: UINT8, /// 한글과 영문 사이 자동 간격 조정 / Auto spacing adjustment between Korean and English pub auto_spacing_ko_en: bool, /// 한글과 숫자 사이 자동 간격 조정 / Auto spacing adjustment between Korean and number pub auto_spacing_ko_num: bool, } /// 줄 간격 종류 (5.0.2.5 이상) / Line spacing type (5.0.2.5+) #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum LineSpacingType { /// 글자에 따라 / By character ByCharacter = 0, /// 고정값 / Fixed value Fixed = 1, /// 여백만 지정 / Margin only MarginOnly = 2, /// 최소값 / Minimum value Minimum = 3, } impl LineSpacingType { fn from_bits(bits: u32) -> Self { match bits & 0x0000001F { 1 => LineSpacingType::Fixed, 2 => LineSpacingType::MarginOnly, 3 => LineSpacingType::Minimum, _ => LineSpacingType::ByCharacter, } } } /// 문단 모양 속성3 / Paragraph shape attributes 3 #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ParaShapeAttributes3 { /// 줄 간격 종류 (bit 0-4, 표 46 참조) / Line spacing type (bit 0-4, See Table 46) pub line_spacing_type: LineSpacingType, } /// ParaShape 구조체 / ParaShape structure #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ParaShape { /// 속성1 (표 44) / Attributes 1 (Table 44) pub attributes1: ParaShapeAttributes1, /// 왼쪽 여백 / Left margin pub left_margin: INT32, /// 오른쪽 여백 / Right margin pub right_margin: INT32, /// 들여쓰기 / Indent pub indent: INT32, /// 내어쓰기 / Outdent pub outdent: INT32, /// 문단 위 간격 / Paragraph top spacing pub top_spacing: INT32, /// 문단 아래 간격 / Paragraph bottom spacing pub bottom_spacing: INT32, /// 줄 간격(한글 2007 이하 버전) / Line spacing (HWP 2007 and below) pub line_spacing_old: INT32, /// 탭 정의 ID 참조 값 / Tab definition ID reference pub tab_def_id: UINT16, /// 번호/글머리표 ID 참조 값 / Number/bullet ID reference pub number_bullet_id: UINT16, /// 테두리/배경 ID 참조 값 / Border/fill ID reference pub border_fill_id: UINT16, /// 문단 테두리 간격(왼쪽) / Paragraph border spacing (left) pub border_spacing_left: INT16, /// 문단 테두리 간격(오른쪽) / Paragraph border spacing (right) pub border_spacing_right: INT16, /// 문단 테두리 간격(위) / Paragraph border spacing (top) pub border_spacing_top: INT16, /// 문단 테두리 간격(아래) / Paragraph border spacing (bottom) pub border_spacing_bottom: INT16, /// 속성2 (표 45, 5.0.1.7 이상, 옵션) / Attributes 2 (Table 45, 5.0.1.7+, optional) pub attributes2: Option<ParaShapeAttributes2>, /// 속성3 (표 46, 5.0.2.5 이상, 옵션) / Attributes 3 (Table 46, 5.0.2.5+, optional) pub attributes3: Option<ParaShapeAttributes3>, /// 줄 간격(5.0.2.5 이상, 옵션) / Line spacing (5.0.2.5+, optional) pub line_spacing: Option<INT32>, } impl ParaShape { /// ParaShape을 바이트 배열에서 파싱합니다. / Parse ParaShape from byte array. /// /// # Arguments /// * `data` - ParaShape 레코드 데이터 / ParaShape record data /// * `version` - HWP 파일 버전 (5.0.1.7 이상에서 속성2 지원, 5.0.2.5 이상에서 속성3 및 줄 간격 지원) / HWP file version (attributes2 supported in 5.0.1.7+, attributes3 and line spacing in 5.0.2.5+) /// /// # Returns /// 파싱된 ParaShape 구조체 / Parsed ParaShape structure pub fn parse(data: &[u8], version: u32) -> Result<Self, HwpError> { // 최소 46바이트 필요 (속성1 4 + 여백/간격 28 + ID 6 + 테두리 간격 8) / Need at least 46 bytes if data.len() < 46 { return Err(HwpError::insufficient_data("ParaShape", 46, data.len())); } let mut offset = 0; // UINT32 속성1 (표 44) / UINT32 attributes1 (Table 44) let attr1_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let attributes1 = ParaShapeAttributes1 { line_spacing_type_old: LineSpacingTypeOld::from_bits(attr1_value), align: ParagraphAlignment::from_bits(attr1_value), line_divide_en: LineDivideUnit::from_bits_en(attr1_value), line_divide_ko: LineDivideUnit::from_bit_ko((attr1_value & 0x00000080) != 0), use_line_grid: (attr1_value & 0x00000100) != 0, blank_min_value: ((attr1_value >> 9) & 0x0000007F) as UINT8, protect_orphan_line: (attr1_value & 0x00010000) != 0, with_next_paragraph: (attr1_value & 0x00020000) != 0, protect_paragraph: (attr1_value & 0x00040000) != 0, always_page_break_before: (attr1_value & 0x00080000) != 0, vertical_align: VerticalAlignment::from_bits(attr1_value), line_height_matches_font: (attr1_value & 0x00400000) != 0, header_shape_type: HeaderShapeType::from_bits(attr1_value), paragraph_level: ((attr1_value >> 25) & 0x00000007) as UINT8, connect_border: (attr1_value & 0x10000000) != 0, ignore_margin: (attr1_value & 0x20000000) != 0, tail_shape: (attr1_value & 0x40000000) != 0, }; // INT32 왼쪽 여백 / INT32 left margin let left_margin = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // INT32 오른쪽 여백 / INT32 right margin let right_margin = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // INT32 들여쓰기 / INT32 indent let indent = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // INT32 내어쓰기 / INT32 outdent let outdent = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // INT32 문단 위 간격 / INT32 paragraph top spacing let top_spacing = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // INT32 문단 아래 간격 / INT32 paragraph bottom spacing let bottom_spacing = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // INT32 줄 간격(한글 2007 이하 버전) / INT32 line spacing (HWP 2007 and below) let line_spacing_old = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // UINT16 탭 정의 ID 참조 값 / UINT16 tab definition ID reference let tab_def_id = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT16 번호/글머리표 ID 참조 값 / UINT16 number/bullet ID reference let number_bullet_id = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT16 테두리/배경 ID 참조 값 / UINT16 border/fill ID reference let border_fill_id = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // INT16 문단 테두리 간격(왼쪽) / INT16 paragraph border spacing (left) let border_spacing_left = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // INT16 문단 테두리 간격(오른쪽) / INT16 paragraph border spacing (right) let border_spacing_right = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // INT16 문단 테두리 간격(위) / INT16 paragraph border spacing (top) let border_spacing_top = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // INT16 문단 테두리 간격(아래) / INT16 paragraph border spacing (bottom) let border_spacing_bottom = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT32 속성2 (표 45, 5.0.1.7 이상) / UINT32 attributes2 (Table 45, 5.0.1.7+) let attributes2 = if version >= 0x00010107 && offset + 4 <= data.len() { let attr2_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; Some(ParaShapeAttributes2 { single_line_input: (attr2_value & 0x00000003) as UINT8, auto_spacing_ko_en: (attr2_value & 0x00000010) != 0, auto_spacing_ko_num: (attr2_value & 0x00000020) != 0, }) } else { None }; // UINT32 속성3 (표 46, 5.0.2.5 이상) / UINT32 attributes3 (Table 46, 5.0.2.5+) let attributes3 = if version >= 0x00020500 && offset + 4 <= data.len() { let attr3_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; Some(ParaShapeAttributes3 { line_spacing_type: LineSpacingType::from_bits(attr3_value), }) } else { None }; // INT32 줄 간격(5.0.2.5 이상) / INT32 line spacing (5.0.2.5+) let line_spacing = if version >= 0x00020500 && offset + 4 <= data.len() { let value = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; Some(value) } else { None }; Ok(ParaShape { attributes1, left_margin, right_margin, indent, outdent, top_spacing, bottom_spacing, line_spacing_old, tab_def_id, number_bullet_id, border_fill_id, border_spacing_left, border_spacing_right, border_spacing_top, border_spacing_bottom, attributes2, attributes3, line_spacing, }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/layout_compatibility.rs

crates/hwp-core/src/document/docinfo/layout_compatibility.rs

/// LayoutCompatibility 구조체 / LayoutCompatibility structure /// /// 스펙 문서 매핑: 표 56 - 레이아웃 호환성 / Spec mapping: Table 56 - Layout compatibility use crate::error::HwpError; use crate::types::UINT32; use serde::{Deserialize, Serialize}; /// 레이아웃 호환성 (표 56) / Layout compatibility (Table 56) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct LayoutCompatibility { /// 글자 단위 서식 / Character unit format pub character_format: UINT32, /// 문단 단위 서식 / Paragraph unit format pub paragraph_format: UINT32, /// 구역 단위 서식 / Section unit format pub section_format: UINT32, /// 개체 단위 서식 / Object unit format pub object_format: UINT32, /// 필드 단위 서식 / Field unit format pub field_format: UINT32, } impl LayoutCompatibility { /// LayoutCompatibility를 바이트 배열에서 파싱합니다. / Parse LayoutCompatibility from byte array. /// /// # Arguments /// * `data` - LayoutCompatibility 데이터 (20바이트) / LayoutCompatibility data (20 bytes) /// /// # Returns /// 파싱된 LayoutCompatibility 구조체 / Parsed LayoutCompatibility structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 20 { return Err(HwpError::insufficient_data("LayoutCompatibility", 20, data.len())); } Ok(LayoutCompatibility { character_format: UINT32::from_le_bytes([data[0], data[1], data[2], data[3]]), paragraph_format: UINT32::from_le_bytes([data[4], data[5], data[6], data[7]]), section_format: UINT32::from_le_bytes([data[8], data[9], data[10], data[11]]), object_format: UINT32::from_le_bytes([data[12], data[13], data[14], data[15]]), field_format: UINT32::from_le_bytes([data[16], data[17], data[18], data[19]]), }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/docinfo/forbidden_char.rs

crates/hwp-core/src/document/docinfo/forbidden_char.rs

/// ForbiddenChar 구조체 / ForbiddenChar structure /// /// 스펙 문서 매핑: 표 4 - 금칙처리 문자 / Spec mapping: Table 4 - Forbidden character /// 상세 구조는 스펙 문서에 명시되지 않음 / Detailed structure not specified in spec use crate::error::HwpError; use serde::{Deserialize, Serialize}; /// 금칙처리 문자 / Forbidden character #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ForbiddenChar { /// Raw data (가변) / Raw data (variable) #[serde(skip)] pub raw_data: Vec<u8>, } impl ForbiddenChar { /// ForbiddenChar를 바이트 배열에서 파싱합니다. / Parse ForbiddenChar from byte array. /// /// # Arguments /// * `data` - ForbiddenChar 데이터 (가변) / ForbiddenChar data (variable) /// /// # Returns /// 파싱된 ForbiddenChar 구조체 / Parsed ForbiddenChar structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { Ok(ForbiddenChar { raw_data: data.to_vec(), }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/memo_list.rs

crates/hwp-core/src/document/bodytext/memo_list.rs

/// MemoList 구조체 / MemoList structure /// /// **구현 상태 / Implementation Status** /// - 구현 완료 / Implementation complete /// - 스펙 문서에 상세 구조가 명시되어 있지 않음 / Spec document does not specify detailed structure /// - 테스트 파일(`noori.hwp`)에 MEMO_LIST 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain MEMO_LIST records use crate::error::HwpError; use serde::{Deserialize, Serialize}; /// 메모 리스트 헤더 / Memo list header #[derive(Debug, Clone, Serialize, Deserialize)] pub struct MemoList { /// Raw 데이터 / Raw data /// 스펙 문서에 상세 구조가 명시되어 있지 않으므로 raw 데이터로 저장합니다. /// Raw data is stored because the spec document does not specify detailed structure. #[serde(skip_serializing_if = "Vec::is_empty")] pub raw_data: Vec<u8>, } impl MemoList { /// MemoList을 바이트 배열에서 파싱합니다. / Parse MemoList from byte array. /// /// # Arguments /// * `data` - MemoList 데이터 / MemoList data /// /// # Returns /// 파싱된 MemoList 구조체 / Parsed MemoList structure /// /// # Note /// 스펙 문서 표 57에는 "메모 리스트 헤더"로만 언급되어 있고 상세 구조가 명시되어 있지 않습니다. /// 레거시 코드(hwp.js)도 raw 데이터로만 저장하고 있습니다. /// Spec document Table 57 only mentions "Memo list header" and does not specify detailed structure. /// Legacy code (hwp.js) also stores only raw data. /// /// **테스트 상태 / Testing Status** /// 현재 테스트 파일(`noori.hwp`)에 MEMO_LIST 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 MEMO_LIST 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain MEMO_LIST records, so it has not been verified with actual files. /// If an actual HWP file contains MEMO_LIST records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { Ok(MemoList { raw_data: data.to_vec(), }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/eqedit.rs

crates/hwp-core/src/document/bodytext/eqedit.rs

/// EqEdit 구조체 / EqEdit structure /// /// 스펙 문서 매핑: 표 105 - 수식 개체 속성 / Spec mapping: Table 105 - Equation editor object attributes /// /// **구현 상태 / Implementation Status** /// - 구현 완료 / Implementation complete /// - 테스트 파일(`noori.hwp`)에 EQEDIT 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain EQEDIT records use crate::error::HwpError; use crate::types::{decode_utf16le, COLORREF, HWPUNIT, INT16, UINT16, UINT32}; use serde::{Deserialize, Serialize}; /// 수식 개체 / Equation editor object #[derive(Debug, Clone, Serialize, Deserialize)] pub struct EqEdit { /// 속성. 스크립트가 차지하는 범위. 첫 비트가 켜져 있으면 줄 단위, 꺼져 있으면 글자 단위. /// Attribute. Range occupied by script. If first bit is set, line unit; otherwise, character unit. pub attribute: UINT32, /// 스크립트 길이 / Script length pub script_length: UINT16, /// 한글 수식 스크립트 / HWP equation script (EQN script compatible) pub script: String, /// 수식 글자 크기 / Equation character size pub character_size: HWPUNIT, /// 글자 색상 / Character color pub character_color: COLORREF, /// base line / Base line pub base_line: INT16, /// 수식 버전 정보 / Equation version information pub version_info: String, /// 수식 폰트 이름 / Equation font name pub font_name: String, } impl EqEdit { /// EqEdit을 바이트 배열에서 파싱합니다. / Parse EqEdit from byte array. /// /// # Arguments /// * `data` - EqEdit 데이터 (수식 개체 속성 부분만) / EqEdit data (equation editor object attributes only) /// /// # Returns /// 파싱된 EqEdit 구조체 / Parsed EqEdit structure /// /// # Note /// 스펙 문서 표 104에 따르면 EQEDIT는 다음 구조를 가집니다: /// - 개체 공통 속성(표 68 참조) - 가변 길이 /// - 수식 개체 속성(표 105 참조) - 가변 길이 (16 + 6×len 바이트) /// /// 레거시 코드(hwp.js)는 수식 개체 속성의 일부만 파싱하고 있습니다. /// According to spec Table 104, EQEDIT has the following structure: /// - Object common properties (Table 68) - variable length /// - Equation editor object attributes (Table 105) - variable length (16 + 6×len bytes) /// /// Legacy code (hwp.js) only parses part of equation editor object attributes. /// /// **테스트 상태 / Testing Status** /// 현재 테스트 파일(`noori.hwp`)에 EQEDIT 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 EQEDIT 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain EQEDIT records, so it has not been verified with actual files. /// If an actual HWP file contains EQEDIT records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // 최소 16바이트 필요 (len=0일 때) / Need at least 16 bytes (when len=0) if data.len() < 16 { return Err(HwpError::insufficient_data("EqEdit", 16, data.len())); } let mut offset = 0; // 표 105: 속성 (UINT32, 4바이트) / Table 105: Attribute (UINT32, 4 bytes) let attribute = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 105: 스크립트 길이 (WORD, 2바이트) / Table 105: Script length (WORD, 2 bytes) let script_length = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let script_length_usize = script_length as usize; // 필요한 바이트 수 계산 / Calculate required bytes // UINT32(4) + WORD(2) + WCHAR array[len](2×len) + HWPUNIT(4) + COLORREF(4) + INT16(2) + WCHAR array[len](2×len) + WCHAR array[len](2×len) // = 16 + 6×len let required_bytes = 16 + 6 * script_length_usize; if data.len() < required_bytes { return Err(HwpError::InsufficientData { field: format!("EqEdit (script_length={})", script_length_usize), expected: required_bytes, actual: data.len(), }); } // 표 105: 한글 수식 스크립트 (WCHAR array[len], 2×len 바이트) / Table 105: HWP equation script (WCHAR array[len], 2×len bytes) let script_bytes = &data[offset..offset + 2 * script_length_usize]; let script = decode_utf16le(script_bytes) .map_err(|e| HwpError::EncodingError { reason: format!("Failed to decode EqEdit script: {}", e), })?; offset += 2 * script_length_usize; // 표 105: 수식 글자 크기 (HWPUNIT, 4바이트) / Table 105: Equation character size (HWPUNIT, 4 bytes) let character_size_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); let character_size = HWPUNIT::from(character_size_value); offset += 4; // 표 105: 글자 색상 (COLORREF, 4바이트) / Table 105: Character color (COLORREF, 4 bytes) let color_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); let character_color = COLORREF(color_value); offset += 4; // 표 105: base line (INT16, 2바이트) / Table 105: Base line (INT16, 2 bytes) let base_line = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // 표 105: 수식 버전 정보 (WCHAR array[len], 2×len 바이트) / Table 105: Equation version information (WCHAR array[len], 2×len bytes) let version_bytes = &data[offset..offset + 2 * script_length_usize]; let version_info = decode_utf16le(version_bytes) .map_err(|e| HwpError::EncodingError { reason: format!("Failed to decode EqEdit version_info: {}", e), })?; offset += 2 * script_length_usize; // 표 105: 수식 폰트 이름 (WCHAR array[len], 2×len 바이트) / Table 105: Equation font name (WCHAR array[len], 2×len bytes) let font_bytes = &data[offset..offset + 2 * script_length_usize]; let font_name = decode_utf16le(font_bytes) .map_err(|e| HwpError::EncodingError { reason: format!("Failed to decode EqEdit font_name: {}", e), })?; offset += 2 * script_length_usize; Ok(EqEdit { attribute, script_length, script, character_size, character_color, base_line, version_info, font_name, }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/record_tree.rs

crates/hwp-core/src/document/bodytext/record_tree.rs

/// 레코드 트리 구조 / Record tree structure /// /// HWP 레코드는 계층 구조로 저장되며, 레벨 정보를 통해 트리 구조를 재구성할 수 있습니다. /// HWP records are stored in a hierarchical structure, and the tree structure can be reconstructed using level information. use crate::error::HwpError; use crate::types::RecordHeader; /// 레코드 트리 노드 / Record tree node #[derive(Debug, Clone)] pub struct RecordTreeNode { /// 레코드 헤더 / Record header pub header: RecordHeader, /// 레코드 데이터 / Record data pub data: Vec<u8>, /// 자식 노드들 / Child nodes pub children: Vec<RecordTreeNode>, } impl RecordTreeNode { /// 레코드 트리를 파싱합니다. / Parse record tree. /// /// hwp.js의 parseRecordTree 로직을 정확히 따라갑니다: /// Follows hwp.js's parseRecordTree logic exactly: /// ```typescript /// let parent: HWPRecord = root /// for (let i = 0; i < level; i += 1) { /// parent = parent.children.slice(-1).pop()! /// } /// parent.children.push(new HWPRecord(...)) /// ``` /// /// # Arguments /// * `data` - Section의 원시 바이트 데이터 / Raw byte data of section /// /// # Returns /// 루트 노드 (레벨 0 레코드들이 자식으로 포함됨) / Root node (level 0 records are included as children) pub fn parse_tree(data: &[u8]) -> Result<RecordTreeNode, HwpError> { let root = RecordTreeNode { header: RecordHeader { tag_id: 0, level: 0, size: 0, has_extended_size: false, }, data: Vec::new(), children: Vec::new(), }; let mut offset = 0; // 스택: 각 레벨의 마지막 노드 참조를 저장 / Stack: stores reference to last node at each level // hwp.js 방식: for (let i = 0; i < level; i += 1) { parent = parent.children.slice(-1).pop()! } // hwp.js way: for (let i = 0; i < level; i += 1) { parent = parent.children.slice(-1).pop()! } // 스택[i]는 레벨 i의 마지막 노드 인덱스 / stack[i] is the last node index at level i // 레벨 i의 부모는 스택[i-1] (레벨 0의 부모는 루트) / Parent of level i is stack[i-1] (parent of level 0 is root) let mut stack: Vec<usize> = Vec::new(); // 각 레벨의 마지막 노드 인덱스 / Last node index at each level let mut nodes: Vec<(RecordTreeNode, Vec<usize>)> = Vec::new(); // (노드, 자식 인덱스 리스트) / (node, child indices) nodes.push((root, Vec::new())); while offset < data.len() { // 레코드 헤더 파싱 / Parse record header let remaining_data = &data[offset..]; let (header, header_size) = RecordHeader::parse(remaining_data) .map_err(|e| HwpError::from(e))?; offset += header_size; // 데이터 영역 읽기 / Read data area let data_size = header.size as usize; if offset + data_size > data.len() { return Err(HwpError::InsufficientData { field: format!("Record at offset {}", offset), expected: offset + data_size, actual: data.len(), }); } let record_data = &data[offset..offset + data_size]; offset += data_size; // 새 노드 생성 / Create new node let new_node = RecordTreeNode { header, data: record_data.to_vec(), children: Vec::new(), }; let new_node_index = nodes.len(); nodes.push((new_node, Vec::new())); // 부모 노드 찾기: hwp.js 로직 정확히 따라가기 // Find parent node: follow hwp.js logic exactly // hwp.js: for (let i = 0; i < level; i += 1) { parent = parent.children.slice(-1).pop()! } // 즉, 레벨만큼 깊이 들어가서 마지막 자식을 부모로 선택 // That is, go level deep and select the last child as parent // 스택을 레벨에 맞게 조정: 레벨이 감소하면 상위 레벨로 돌아감 // Adjust stack to match level: if level decreases, return to higher level while stack.len() > header.level as usize { stack.pop(); } // 부모 노드 찾기 / Find parent node let parent_index = if header.level == 0 { 0 // 루트 / Root } else { // 스택을 레벨에 맞게 확장 / Expand stack to match level while stack.len() < header.level as usize { // 스택이 부족하면 이전 레벨의 마지막 노드를 사용 / Use last node of previous level if stack is insufficient if let Some(&last) = stack.last() { stack.push(last); } else { stack.push(0); // 루트 / Root } } // 레벨 i의 부모는 레벨 i-1의 마지막 노드 (스택[i-1]) // Parent of level i is last node at level i-1 (stack[i-1]) stack[header.level as usize - 1] }; // 부모에 자식 추가 / Add child to parent nodes[parent_index].1.push(new_node_index); // 새 노드를 스택에 추가 (다음 레코드의 부모가 될 수 있음) // Add new node to stack (can be parent of next record) // 스택을 레벨 크기로 확장 / Expand stack to level size while stack.len() <= header.level as usize { stack.push(0); // 플레이스홀더 / Placeholder } stack[header.level as usize] = new_node_index; } // 인덱스 기반 트리를 실제 트리로 변환 / Convert index-based tree to actual tree fn build_tree(nodes: &[(RecordTreeNode, Vec<usize>)], index: usize) -> RecordTreeNode { let (node, children_indices) = &nodes[index]; let mut result = RecordTreeNode { header: node.header, data: node.data.clone(), children: Vec::new(), }; for &child_index in children_indices { result.children.push(build_tree(nodes, child_index)); } result } Ok(build_tree(&nodes, 0)) } /// 태그 ID 반환 / Get tag ID pub fn tag_id(&self) -> u16 { self.header.tag_id } /// 레벨 반환 / Get level pub fn level(&self) -> u16 { self.header.level } /// 데이터 반환 / Get data pub fn data(&self) -> &[u8] { &self.data } /// 자식 노드들 반환 / Get children pub fn children(&self) -> &[RecordTreeNode] { &self.children } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/line_seg.rs

crates/hwp-core/src/document/bodytext/line_seg.rs

/// LineSegmentInfo 구조체 / LineSegmentInfo structure /// /// 스펙 문서 매핑: 표 62 - 문단의 레이아웃 / Spec mapping: Table 62 - Paragraph line segment /// 각 항목: 36바이트 use crate::error::HwpError; use crate::types::{INT32, UINT32}; use serde::{Deserialize, Serialize}; /// 줄 세그먼트 태그 플래그 / Line segment tag flags #[derive(Debug, Clone, Serialize, Deserialize)] pub struct LineSegmentTag { /// 페이지의 첫 줄인지 여부 / Is first line of page pub is_first_line_of_page: bool, /// 컬럼의 첫 줄인지 여부 / Is first line of column pub is_first_line_of_column: bool, /// 텍스트가 배열되지 않은 빈 세그먼트인지 여부 / Is empty segment without text pub is_empty_segment: bool, /// 줄의 첫 세그먼트인지 여부 / Is first segment of line pub is_first_segment_of_line: bool, /// 줄의 마지막 세그먼트인지 여부 / Is last segment of line pub is_last_segment_of_line: bool, /// 줄의 마지막에 auto-hyphenation이 수행되었는지 여부 / Auto-hyphenation performed at end of line pub has_auto_hyphenation: bool, /// indentation 적용 / Indentation applied pub has_indentation: bool, /// 문단 머리 모양 적용 / Paragraph header shape applied pub has_paragraph_header_shape: bool, } impl LineSegmentTag { /// UINT32 태그 값에서 LineSegmentTag를 파싱합니다. / Parse LineSegmentTag from UINT32 tag value. fn from_bits(tag: UINT32) -> Self { LineSegmentTag { is_first_line_of_page: (tag & 0x00000001) != 0, is_first_line_of_column: (tag & 0x00000002) != 0, is_empty_segment: (tag & 0x00010000) != 0, is_first_segment_of_line: (tag & 0x00020000) != 0, is_last_segment_of_line: (tag & 0x00040000) != 0, has_auto_hyphenation: (tag & 0x00080000) != 0, has_indentation: (tag & 0x00100000) != 0, has_paragraph_header_shape: (tag & 0x00200000) != 0, } } } /// 줄 세그먼트 정보 / Line segment information #[derive(Debug, Clone, Serialize, Deserialize)] pub struct LineSegmentInfo { /// 텍스트 시작 위치 / Text start position pub text_start_position: UINT32, /// 줄의 세로 위치 / Vertical position of line pub vertical_position: INT32, /// 줄의 높이 / Height of line pub line_height: INT32, /// 텍스트 부분의 높이 / Height of text portion pub text_height: INT32, /// 줄의 세로 위치에서 베이스라인까지 거리 / Distance from vertical position to baseline pub baseline_distance: INT32, /// 줄간격 / Line spacing pub line_spacing: INT32, /// 컬럼에서의 시작 위치 / Start position in column pub column_start_position: INT32, /// 세그먼트의 폭 / Width of segment pub segment_width: INT32, /// 태그 (플래그들) / Tag (flags) pub tag: LineSegmentTag, } impl LineSegmentInfo { /// LineSegmentInfo를 바이트 배열에서 파싱합니다. / Parse LineSegmentInfo from byte array. /// /// # Arguments /// * `data` - 최소 36바이트의 데이터 / At least 36 bytes of data /// /// # Returns /// 파싱된 LineSegmentInfo 구조체 / Parsed LineSegmentInfo structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 36 { return Err(HwpError::insufficient_data("LineSegmentInfo", 36, data.len())); } let mut offset = 0; // UINT32 텍스트 시작 위치 / UINT32 text start position let text_start_position = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // INT32 줄의 세로 위치 / INT32 vertical position of line let vertical_position = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // INT32 줄의 높이 / INT32 height of line let line_height = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // INT32 텍스트 부분의 높이 / INT32 height of text portion let text_height = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // INT32 줄의 세로 위치에서 베이스라인까지 거리 / INT32 distance from vertical position to baseline let baseline_distance = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // INT32 줄간격 / INT32 line spacing let line_spacing = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // INT32 컬럼에서의 시작 위치 / INT32 start position in column let column_start_position = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // INT32 세그먼트의 폭 / INT32 width of segment let segment_width = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // UINT32 태그 / UINT32 tag let tag_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); let tag = LineSegmentTag::from_bits(tag_value); Ok(LineSegmentInfo { text_start_position, vertical_position, line_height, text_height, baseline_distance, line_spacing, column_start_position, segment_width, tag, }) } } /// 문단의 레이아웃 리스트 / Paragraph line segment list #[derive(Debug, Clone, Default, Serialize, Deserialize)] pub struct ParaLineSeg { /// 줄 세그먼트 정보 리스트 / Line segment information list pub segments: Vec<LineSegmentInfo>, } impl ParaLineSeg { /// ParaLineSeg를 바이트 배열에서 파싱합니다. / Parse ParaLineSeg from byte array. /// /// # Arguments /// * `data` - 레이아웃 데이터 (36×n 바이트) / Line segment data (36×n bytes) /// /// # Returns /// 파싱된 ParaLineSeg 구조체 / Parsed ParaLineSeg structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() % 36 != 0 { return Err(HwpError::UnexpectedValue { field: "ParaLineSeg data length".to_string(), expected: "multiple of 36".to_string(), found: format!("{} bytes", data.len()), }); } let count = data.len() / 36; let mut segments = Vec::with_capacity(count); for i in 0..count { let offset = i * 36; let segment_data = &data[offset..offset + 36]; let segment_info = LineSegmentInfo::parse(segment_data) .map_err(|e| HwpError::from(e))?; segments.push(segment_info); } Ok(ParaLineSeg { segments }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/char_shape.rs

crates/hwp-core/src/document/bodytext/char_shape.rs

/// CharShapeInfo 구조체 / CharShapeInfo structure /// /// 스펙 문서 매핑: 표 61 - 문단의 글자 모양 / Spec mapping: Table 61 - Paragraph character shape /// 각 항목: 8바이트 use crate::error::HwpError; use crate::types::UINT32; use serde::{Deserialize, Serialize}; /// 글자 모양 정보 / Character shape information #[derive(Debug, Clone, Serialize, Deserialize)] pub struct CharShapeInfo { /// 글자 모양이 바뀌는 시작 위치 / Position where character shape changes pub position: UINT32, /// 글자 모양 ID / Character shape ID pub shape_id: UINT32, } impl CharShapeInfo { /// CharShapeInfo를 바이트 배열에서 파싱합니다. / Parse CharShapeInfo from byte array. /// /// # Arguments /// * `data` - 최소 8바이트의 데이터 / At least 8 bytes of data /// /// # Returns /// 파싱된 CharShapeInfo 구조체 / Parsed CharShapeInfo structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 8 { return Err(HwpError::insufficient_data("CharShapeInfo", 8, data.len())); } // UINT32 글자 모양이 바뀌는 시작 위치 / UINT32 position where character shape changes let position = UINT32::from_le_bytes([data[0], data[1], data[2], data[3]]); // UINT32 글자 모양 ID / UINT32 character shape ID let shape_id = UINT32::from_le_bytes([data[4], data[5], data[6], data[7]]); Ok(CharShapeInfo { position, shape_id }) } } /// 문단의 글자 모양 리스트 / Paragraph character shape list #[derive(Debug, Clone, Default, Serialize, Deserialize)] pub struct ParaCharShape { /// 글자 모양 정보 리스트 / Character shape information list pub shapes: Vec<CharShapeInfo>, } impl ParaCharShape { /// ParaCharShape를 바이트 배열에서 파싱합니다. / Parse ParaCharShape from byte array. /// /// # Arguments /// * `data` - 글자 모양 데이터 (8×n 바이트) / Character shape data (8×n bytes) /// /// # Returns /// 파싱된 ParaCharShape 구조체 / Parsed ParaCharShape structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() % 8 != 0 { return Err(HwpError::UnexpectedValue { field: "ParaCharShape data length".to_string(), expected: "multiple of 8".to_string(), found: format!("{} bytes", data.len()), }); } let count = data.len() / 8; let mut shapes = Vec::with_capacity(count); for i in 0..count { let offset = i * 8; let shape_data = &data[offset..offset + 8]; let shape_info = CharShapeInfo::parse(shape_data) .map_err(|e| HwpError::from(e))?; shapes.push(shape_info); } Ok(ParaCharShape { shapes }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/page_def.rs

crates/hwp-core/src/document/bodytext/page_def.rs

/// PageDef 구조체 / PageDef structure /// /// 스펙 문서 매핑: 표 131 - 용지 설정 / Spec mapping: Table 131 - Page definition use crate::error::HwpError; use crate::types::{HWPUNIT, UINT32}; use serde::{Deserialize, Serialize}; /// 용지 설정 / Page definition #[derive(Debug, Clone, Serialize, Deserialize)] pub struct PageDef { /// 용지 가로 크기 / Paper width pub paper_width: HWPUNIT, /// 용지 세로 크기 / Paper height pub paper_height: HWPUNIT, /// 용지 왼쪽 여백 / Left margin pub left_margin: HWPUNIT, /// 오른쪽 여백 / Right margin pub right_margin: HWPUNIT, /// 위 여백 / Top margin pub top_margin: HWPUNIT, /// 아래 여백 / Bottom margin pub bottom_margin: HWPUNIT, /// 머리말 여백 / Header margin pub header_margin: HWPUNIT, /// 꼬리말 여백 / Footer margin pub footer_margin: HWPUNIT, /// 제본 여백 / Binding margin pub binding_margin: HWPUNIT, /// 속성 / Attributes pub attributes: PageDefAttributes, } /// 용지 설정 속성 / Page definition attributes #[derive(Debug, Clone, Serialize, Deserialize)] pub struct PageDefAttributes { /// 용지 방향 / Paper direction pub paper_direction: PaperDirection, /// 제책 방법 / Binding method pub binding_method: BindingMethod, } /// 용지 방향 / Paper direction #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum PaperDirection { /// 좁게 (세로) / Vertical (narrow) Vertical, /// 넓게 (가로) / Horizontal (wide) Horizontal, } /// 제책 방법 / Binding method #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum BindingMethod { /// 한쪽 편집 / Single page editing SinglePage, /// 맞쪽 편집 / Facing pages editing FacingPages, /// 위로 넘기기 / Flip up FlipUp, } impl PageDef { /// PageDef를 바이트 배열에서 파싱합니다. / Parse PageDef from byte array. /// /// # Arguments /// * `data` - 최소 40바이트의 데이터 / At least 40 bytes of data /// /// # Returns /// 파싱된 PageDef 구조체 / Parsed PageDef structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 40 { return Err(HwpError::insufficient_data("PageDef", 40, data.len())); } let mut offset = 0; // HWPUNIT 용지 가로 크기 / HWPUNIT paper width let paper_width = HWPUNIT::from(UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; // HWPUNIT 용지 세로 크기 / HWPUNIT paper height let paper_height = HWPUNIT::from(UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; // HWPUNIT 용지 왼쪽 여백 / HWPUNIT left margin let left_margin = HWPUNIT::from(UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; // HWPUNIT 오른쪽 여백 / HWPUNIT right margin let right_margin = HWPUNIT::from(UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; // HWPUNIT 위 여백 / HWPUNIT top margin let top_margin = HWPUNIT::from(UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; // HWPUNIT 아래 여백 / HWPUNIT bottom margin let bottom_margin = HWPUNIT::from(UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; // HWPUNIT 머리말 여백 / HWPUNIT header margin let header_margin = HWPUNIT::from(UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; // HWPUNIT 꼬리말 여백 / HWPUNIT footer margin let footer_margin = HWPUNIT::from(UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; // HWPUNIT 제본 여백 / HWPUNIT binding margin let binding_margin = HWPUNIT::from(UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; // UINT32 속성 (표 132 참조) / UINT32 attributes (see Table 132) let attribute_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); // 속성 파싱 (표 132) / Parse attributes (Table 132) let attributes = parse_page_def_attributes(attribute_value); Ok(PageDef { paper_width, paper_height, left_margin, right_margin, top_margin, bottom_margin, header_margin, footer_margin, binding_margin, attributes, }) } } /// 용지 설정 속성 파싱 (표 132) / Parse page definition attributes (Table 132) fn parse_page_def_attributes(value: UINT32) -> PageDefAttributes { // bit 0: 용지 방향 / bit 0: paper direction // 0: 좁게 (세로) / 0: vertical (narrow) // 1: 넓게 (가로) / 1: horizontal (wide) let paper_direction = if (value & 0x01) == 0 { PaperDirection::Vertical } else { PaperDirection::Horizontal }; // bit 1-2: 제책 방법 / bit 1-2: binding method // 0: 한쪽 편집 / 0: single page editing // 1: 맞쪽 편집 / 1: facing pages editing // 2: 위로 넘기기 / 2: flip up let binding_method = match (value >> 1) & 0x03 { 0 => BindingMethod::SinglePage, 1 => BindingMethod::FacingPages, 2 => BindingMethod::FlipUp, _ => BindingMethod::SinglePage, // 기본값 / default }; PageDefAttributes { paper_direction, binding_method, } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/footnote_shape.rs

crates/hwp-core/src/document/bodytext/footnote_shape.rs

/// FootnoteShape 구조체 / FootnoteShape structure /// /// 스펙 문서 매핑: 표 133 - 각주/미주 모양 / Spec mapping: Table 133 - Footnote/endnote shape use crate::error::HwpError; use crate::types::{COLORREF, HWPUNIT16, UINT16, UINT32, UINT8, WCHAR}; use serde::{Deserialize, Serialize}; /// 각주/미주 모양 / Footnote/endnote shape #[derive(Debug, Clone, Serialize, Deserialize)] pub struct FootnoteShape { /// 속성 / Attributes pub attributes: FootnoteShapeAttributes, /// 사용자 기호 / Custom symbol pub custom_symbol: WCHAR, /// 앞 장식 문자 / Front decoration character pub front_decoration: WCHAR, /// 뒤 장식 문자 / Back decoration character pub back_decoration: WCHAR, /// 시작 번호 / Start number pub start_number: UINT16, /// 구분선 길이 / Breakline length pub breakline_length: HWPUNIT16, /// 구분선 위 여백 / Breakline top margin pub breakline_top_margin: HWPUNIT16, /// 구분선 아래 여백 / Breakline bottom margin pub breakline_bottom_margin: HWPUNIT16, /// 주석 사이 여백 / Remark between margin pub remark_between_margin: HWPUNIT16, /// 구분선 종류 / Breakline type pub breakline_type: UINT8, /// 구분선 굵기 / Breakline thickness pub breakline_thickness: UINT8, /// 구분선 색상 / Breakline color pub breakline_color: COLORREF, } /// 각주/미주 모양 속성 / Footnote/endnote shape attributes #[derive(Debug, Clone, Serialize, Deserialize)] pub struct FootnoteShapeAttributes { /// 번호 모양 / Number shape pub number_shape: NumberShape, /// 한 페이지 내에서 각주를 다단에 위치시킬 방법 / Page position method for footnotes in multi-column pub page_position: PagePosition, /// 번호 매기기 방법 / Numbering method pub numbering: NumberingMethod, /// 각주 내용 중 번호 코드의 모양을 위 첨자 형식으로 할지 여부 / Superscript format for number code in footnote content pub superscript: bool, /// 텍스트에 이어 바로 출력할지 여부 / Output immediately after text pub prefix: bool, } /// 번호 모양 / Number shape #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum NumberShape { /// 1, 2, 3 Arabic, /// 동그라미 쳐진 1, 2, 3 CircledArabic, /// I, II, III RomanUpper, /// i, ii, iii RomanLower, /// A, B, C AlphaUpper, /// a, b, c AlphaLower, /// 동그라미 쳐진 A, B, C CircledAlphaUpper, /// 동그라미 쳐진 a, b, c CircledAlphaLower, /// 가, 나, 다 Hangul, /// 동그라미 쳐진 가, 나, 다 CircledHangul, /// ㄱ, ㄴ, ㄷ HangulJamo, /// 동그라미 쳐진 ㄱ, ㄴ, ㄷ CircledHangulJamo, /// 일, 이, 삼 HangulNumber, /// 一, 二, 三 ChineseNumber, /// 동그라미 쳐진 一, 二, 三 CircledChineseNumber, /// 갑, 을, 병, 정, 무, 기, 경, 신, 임, 계 HeavenlyStem, /// 甲, 乙, 丙, 丁, 戊, 己, 庚, 辛, 壬, 癸 HeavenlyStemChinese, /// 4가지 문자가 차례로 반복 FourCharRepeat, /// 사용자 지정 문자 반복 CustomCharRepeat, } /// 한 페이지 내에서 각주를 다단에 위치시킬 방법 / Page position method for footnotes in multi-column #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum PagePosition { /// (각주인 경우) 각 단마다 따로 배열 / (For footnote) Arrange separately for each column /// (미주인 경우) 문서의 마지막 / (For endnote) End of document Separate, /// (각주인 경우) 통단으로 배열 / (For footnote) Arrange across columns /// (미주인 경우) 구역의 마지막 / (For endnote) End of section Across, /// (각주인 경우) 가장 오른쪽 단에 배열 / (For footnote) Arrange in rightmost column Rightmost, } /// 번호 매기기 방법 / Numbering method #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum NumberingMethod { /// 앞 구역에 이어서 / Continue from previous section Continue, /// 현재 구역부터 새로 시작 / Start from current section Restart, /// 쪽마다 새로 시작(각주 전용) / Restart per page (footnote only) PerPage, } impl FootnoteShape { /// FootnoteShape를 바이트 배열에서 파싱합니다. / Parse FootnoteShape from byte array. /// /// # Arguments /// * `data` - 최소 26바이트의 데이터 / At least 26 bytes of data /// /// # Returns /// 파싱된 FootnoteShape 구조체 / Parsed FootnoteShape structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 26 { return Err(HwpError::insufficient_data("FootnoteShape", 26, data.len())); } let mut offset = 0; // UINT32 속성 (표 134 참조) / UINT32 attributes (see Table 134) let attribute_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 속성 파싱 (표 134) / Parse attributes (Table 134) let attributes = parse_footnote_shape_attributes(attribute_value); // WCHAR 사용자 기호 / WCHAR custom symbol let custom_symbol = WCHAR::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // WCHAR 앞 장식 문자 / WCHAR front decoration character let front_decoration = WCHAR::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // WCHAR 뒤 장식 문자 / WCHAR back decoration character let back_decoration = WCHAR::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT16 시작 번호 / UINT16 start number let start_number = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // HWPUNIT16 구분선 길이 / HWPUNIT16 breakline length let breakline_length = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // HWPUNIT16 구분선 위 여백 / HWPUNIT16 breakline top margin let breakline_top_margin = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // HWPUNIT16 구분선 아래 여백 / HWPUNIT16 breakline bottom margin let breakline_bottom_margin = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // HWPUNIT16 주석 사이 여백 / HWPUNIT16 remark between margin let remark_between_margin = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT8 구분선 종류 / UINT8 breakline type let breakline_type = data[offset]; offset += 1; // UINT8 구분선 굵기 / UINT8 breakline thickness let breakline_thickness = data[offset]; offset += 1; // COLORREF 구분선 색상 / COLORREF breakline color let breakline_color = COLORREF(u32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; Ok(FootnoteShape { attributes, custom_symbol, front_decoration, back_decoration, start_number, breakline_length, breakline_top_margin, breakline_bottom_margin, remark_between_margin, breakline_type, breakline_thickness, breakline_color, }) } } /// 각주/미주 모양 속성 파싱 (표 134) / Parse footnote/endnote shape attributes (Table 134) fn parse_footnote_shape_attributes(value: UINT32) -> FootnoteShapeAttributes { // bit 0-7: 번호 모양 / bit 0-7: number shape let number_shape_value = (value & 0xFF) as u8; let number_shape = match number_shape_value { 0 => NumberShape::Arabic, 1 => NumberShape::CircledArabic, 2 => NumberShape::RomanUpper, 3 => NumberShape::RomanLower, 4 => NumberShape::AlphaUpper, 5 => NumberShape::AlphaLower, 6 => NumberShape::CircledAlphaUpper, 7 => NumberShape::CircledAlphaLower, 8 => NumberShape::Hangul, 9 => NumberShape::CircledHangul, 10 => NumberShape::HangulJamo, 11 => NumberShape::CircledHangulJamo, 12 => NumberShape::HangulNumber, 13 => NumberShape::ChineseNumber, 14 => NumberShape::CircledChineseNumber, 15 => NumberShape::HeavenlyStem, 16 => NumberShape::HeavenlyStemChinese, 0x80 => NumberShape::FourCharRepeat, 0x81 => NumberShape::CustomCharRepeat, _ => NumberShape::Arabic, // 기본값 / default }; // bit 8-9: 한 페이지 내에서 각주를 다단에 위치시킬 방법 / bit 8-9: page position method let page_position = match (value >> 8) & 0x03 { 0 => PagePosition::Separate, 1 => PagePosition::Across, 2 => PagePosition::Rightmost, _ => PagePosition::Separate, // 기본값 / default }; // bit 10-11: numbering / bit 10-11: numbering method let numbering = match (value >> 10) & 0x03 { 0 => NumberingMethod::Continue, 1 => NumberingMethod::Restart, 2 => NumberingMethod::PerPage, _ => NumberingMethod::Continue, // 기본값 / default }; // bit 12: 각주 내용 중 번호 코드의 모양을 위 첨자 형식으로 할지 여부 / bit 12: superscript format let superscript = (value & 0x1000) != 0; // bit 13: 텍스트에 이어 바로 출력할지 여부 / bit 13: output immediately after text let prefix = (value & 0x2000) != 0; FootnoteShapeAttributes { number_shape, page_position, numbering, superscript, prefix, } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/memo_shape.rs

crates/hwp-core/src/document/bodytext/memo_shape.rs

/// MemoShape 구조체 / MemoShape structure /// /// **구현 상태 / Implementation Status** /// - 구현 완료 / Implementation complete /// - 스펙 문서에 상세 구조가 명시되어 있지 않음 / Spec document does not specify detailed structure /// - 테스트 파일(`noori.hwp`)에 MEMO_SHAPE 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain MEMO_SHAPE records /// /// **참고 / Note** /// DocInfo의 MEMO_SHAPE는 22바이트로 정의되어 있지만, BodyText의 MEMO_SHAPE는 가변 길이입니다. /// DocInfo's MEMO_SHAPE is defined as 22 bytes, but BodyText's MEMO_SHAPE is variable length. use crate::error::HwpError; use serde::{Deserialize, Serialize}; /// 메모 모양 / Memo shape #[derive(Debug, Clone, Serialize, Deserialize)] pub struct MemoShape { /// Raw 데이터 / Raw data /// 스펙 문서에 상세 구조가 명시되어 있지 않으므로 raw 데이터로 저장합니다. /// Raw data is stored because the spec document does not specify detailed structure. #[serde(skip_serializing_if = "Vec::is_empty")] pub raw_data: Vec<u8>, } impl MemoShape { /// MemoShape을 바이트 배열에서 파싱합니다. / Parse MemoShape from byte array. /// /// # Arguments /// * `data` - MemoShape 데이터 / MemoShape data /// /// # Returns /// 파싱된 MemoShape 구조체 / Parsed MemoShape structure /// /// # Note /// 스펙 문서 표 57에는 "메모 모양"으로만 언급되어 있고 상세 구조가 명시되어 있지 않습니다. /// 레거시 코드(hwp.js)도 raw 데이터로만 저장하고 있습니다. /// Spec document Table 57 only mentions "Memo shape" and does not specify detailed structure. /// Legacy code (hwp.js) also stores only raw data. /// /// **테스트 상태 / Testing Status** /// 현재 테스트 파일(`noori.hwp`)에 MEMO_SHAPE 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 MEMO_SHAPE 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain MEMO_SHAPE records, so it has not been verified with actual files. /// If an actual HWP file contains MEMO_SHAPE records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { Ok(MemoShape { raw_data: data.to_vec(), }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/table.rs

crates/hwp-core/src/document/bodytext/table.rs

/// Table 구조체 / Table structure /// /// 스펙 문서 매핑: 표 74 - 표 개체 / Spec mapping: Table 74 - Table object use crate::error::HwpError; use crate::types::{HWPUNIT, HWPUNIT16, UINT16, UINT32}; use serde::{Deserialize, Serialize}; use super::list_header::ListHeader; /// 표 개체 / Table object #[derive(Debug, Clone, Serialize, Deserialize)] pub struct Table { /// 표 개체 속성 (표 75 참조) / Table object attributes (see Table 75) pub attributes: TableAttributes, /// 셀 리스트 (표 79 참조) / Cell list (see Table 79) pub cells: Vec<TableCell>, } /// 표 개체 속성 (표 75) / Table object attributes (Table 75) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct TableAttributes { /// 속성 (표 76 참조) / Attribute (see Table 76) pub attribute: TableAttribute, /// 행 개수 / Row count pub row_count: UINT16, /// 열 개수 / Column count pub col_count: UINT16, /// 셀 간격 / Cell spacing pub cell_spacing: HWPUNIT16, /// 안쪽 여백 정보 (표 77 참조) / Padding information (see Table 77) pub padding: TablePadding, /// 행 크기 리스트 / Row size list pub row_sizes: Vec<HWPUNIT16>, /// 테두리 채우기 ID / Border fill ID pub border_fill_id: UINT16, /// 영역 속성 리스트 (5.0.1.0 이상) / Zone attributes list (5.0.1.0 and above) pub zones: Vec<TableZone>, } /// 표 속성의 속성 (표 76) / Table attribute properties (Table 76) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct TableAttribute { /// 쪽 경계에서 나눔 / Page break behavior pub page_break: PageBreakBehavior, /// 제목 줄 자동 반복 여부 / Header row auto repeat pub header_row_repeat: bool, } /// 쪽 경계에서 나눔 / Page break behavior #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum PageBreakBehavior { /// 나누지 않음 / No break NoBreak, /// 셀 단위로 나눔 / Break by cell BreakByCell, /// 나누지 않음 (다른 값) / No break (other value) NoBreakOther, } /// 안쪽 여백 정보 (표 77) / Padding information (Table 77) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct TablePadding { /// 왼쪽 여백 / Left padding pub left: HWPUNIT16, /// 오른쪽 여백 / Right padding pub right: HWPUNIT16, /// 위쪽 여백 / Top padding pub top: HWPUNIT16, /// 아래쪽 여백 / Bottom padding pub bottom: HWPUNIT16, } /// 영역 속성 (표 78) / Zone attributes (Table 78) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct TableZone { /// 시작 열 주소 / Start column address pub start_col: UINT16, /// 시작 행 주소 / Start row address pub start_row: UINT16, /// 끝 열 주소 / End column address pub end_col: UINT16, /// 끝 행 주소 / End row address pub end_row: UINT16, /// 테두리 채우기 ID / Border fill ID pub border_fill_id: UINT16, } /// 셀 리스트 (표 79) / Cell list (Table 79) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct TableCell { /// 문단 리스트 헤더 (표 65 참조) / Paragraph list header (see Table 65) pub list_header: ListHeader, /// 셀 속성 (표 80 참조) / Cell attributes (see Table 80) pub cell_attributes: CellAttributes, /// 셀 내부의 문단들 (레벨 3) / Paragraphs inside cell (level 3) #[serde(skip_serializing_if = "Vec::is_empty", default)] pub paragraphs: Vec<super::Paragraph>, } /// 셀 속성 (표 80) / Cell attributes (Table 80) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct CellAttributes { /// 열 주소 / Column address pub col_address: UINT16, /// 행 주소 / Row address pub row_address: UINT16, /// 열 병합 개수 / Column merge count pub col_span: UINT16, /// 행 병합 개수 / Row merge count pub row_span: UINT16, /// 폭 / Width pub width: HWPUNIT, /// 높이 / Height pub height: HWPUNIT, /// 왼쪽 여백 / Left margin pub left_margin: HWPUNIT16, /// 오른쪽 여백 / Right margin pub right_margin: HWPUNIT16, /// 위쪽 여백 / Top margin pub top_margin: HWPUNIT16, /// 아래쪽 여백 / Bottom margin pub bottom_margin: HWPUNIT16, /// 테두리/배경 아이디 / Border fill ID pub border_fill_id: UINT16, } impl Table { /// Table을 바이트 배열에서 파싱합니다. / Parse Table from byte array. /// /// # Arguments /// * `data` - Table 데이터 (개체 공통 속성 포함) / Table data (including object common properties) /// * `version` - 파일 버전 / File version /// /// # Returns /// 파싱된 Table 구조체 / Parsed Table structure pub fn parse(data: &[u8], version: u32) -> Result<Self, HwpError> { if data.is_empty() { return Err(HwpError::InsufficientData { field: "Table data".to_string(), expected: 1, actual: 0, }); } let mut offset = 0; // 레거시 코드를 보면 HWPTAG_TABLE은 개체 공통 속성을 건너뛰고 표 개체 속성부터 시작 // According to legacy code, HWPTAG_TABLE skips object common properties and starts from table attributes // 표 개체 속성 파싱 (표 75) / Parse table object attributes (Table 75) let attributes = parse_table_attributes(data, &mut offset, version)?; // IMPORTANT: // HWP 5.x 실데이터에서는 "표 셀"의 실제 메타(행/열, 폭/높이, 마진, borderFill 등)와 // 셀 내부 문단은 대부분 HWPTAG_LIST_HEADER(테이블 셀 리스트) 트리로 제공됩니다. // // legacy hwpjs / pyhwp 구현도 이 LIST_HEADER 기반을 단일 소스로 취급하는 방식이며, // HWPTAG_TABLE payload(표 79/80)를 추정 파싱하면 오프셋 불일치로 "가짜 셀"이 하나 더 생기는 // 케이스(table-caption 등)가 있습니다. // // 따라서 여기서는 HWPTAG_TABLE payload에서 셀 리스트를 만들지 않고, // 트리 결합 단계(document/bodytext/mod.rs)에서 LIST_HEADER 기반으로 table.cells를 구성합니다. let cells = Vec::new(); Ok(Table { attributes, cells }) } } /// 표 개체 속성 파싱 (표 75) / Parse table object attributes (Table 75) fn parse_table_attributes( data: &[u8], offset: &mut usize, version: u32, ) -> Result<TableAttributes, HwpError> { // 최소 22바이트 필요 (기본 필드) / Need at least 22 bytes (basic fields) if data.len() < *offset + 22 { return Err(HwpError::insufficient_data( "Table attributes", 22, data.len() - *offset, )); } // UINT32 속성 (표 76 참조) / UINT32 attribute (see Table 76) let attribute_value = UINT32::from_le_bytes([ data[*offset], data[*offset + 1], data[*offset + 2], data[*offset + 3], ]); *offset += 4; // UINT16 RowCount / UINT16 RowCount let row_count_raw = UINT16::from_le_bytes([data[*offset], data[*offset + 1]]); *offset += 2; // UINT16 nCols / UINT16 nCols let col_count_raw = UINT16::from_le_bytes([data[*offset], data[*offset + 1]]); *offset += 2; // row_count와 col_count는 UINT16이므로 최대 65535까지 가능 / row_count and col_count are UINT16, so max 65535 // JSON에서는 정상적으로 파싱되므로 파싱 자체는 문제없음 / Parsing is fine since JSON shows normal values // 실제 문제는 row_sizes 메모리 손상이므로, row_count/col_count는 그대로 사용 / Actual issue is row_sizes memory corruption, so use row_count/col_count as is let row_count = row_count_raw; let col_count = col_count_raw; // HWPUNIT16 CellSpacing / HWPUNIT16 CellSpacing let cell_spacing = HWPUNIT16::from_le_bytes([data[*offset], data[*offset + 1]]); *offset += 2; // BYTE stream 8 안쪽 여백 정보 (표 77 참조) / BYTE stream 8 padding information (see Table 77) let padding = TablePadding { left: HWPUNIT16::from_le_bytes([data[*offset], data[*offset + 1]]), right: HWPUNIT16::from_le_bytes([data[*offset + 2], data[*offset + 3]]), top: HWPUNIT16::from_le_bytes([data[*offset + 4], data[*offset + 5]]), bottom: HWPUNIT16::from_le_bytes([data[*offset + 6], data[*offset + 7]]), }; *offset += 8; // BYTE stream 2×row Row Size / BYTE stream 2×row Row Size // row_count가 이미 유효성 검사를 거쳤으므로 안전하게 파싱 / row_count is already validated, so safe to parse let mut row_sizes = Vec::new(); for _ in 0..row_count { if *offset + 2 > data.len() { // 데이터가 부족하면 중단하고 지금까지 파싱한 것만 사용 / Stop if insufficient data and use what we've parsed so far break; } row_sizes.push(HWPUNIT16::from_le_bytes([data[*offset], data[*offset + 1]])); *offset += 2; } // row_sizes가 row_count와 일치하지 않으면 빈 Vec로 초기화 / Initialize as empty Vec if row_sizes doesn't match row_count // 메모리 손상 방지를 위해 유효성 검사 / Validate to prevent memory corruption if row_sizes.len() != row_count as usize { row_sizes = Vec::new(); } // UINT16 Border Fill ID / UINT16 Border Fill ID let border_fill_id = UINT16::from_le_bytes([data[*offset], data[*offset + 1]]); *offset += 2; // UINT16 Valid Zone Info Size (5.0.1.0 이상) / UINT16 Valid Zone Info Size (5.0.1.0 and above) let mut zones = Vec::new(); if version >= 5010 { if *offset + 2 > data.len() { return Err(HwpError::insufficient_data( "valid zone info size", 2, data.len() - *offset, )); } let valid_zone_info_size = UINT16::from_le_bytes([data[*offset], data[*offset + 1]]); *offset += 2; // BYTE stream 10×zone 영역 속성 (표 78 참조) / BYTE stream 10×zone zone attributes (see Table 78) let zone_count = valid_zone_info_size as usize / 10; for _ in 0..zone_count { if *offset + 10 > data.len() { return Err(HwpError::insufficient_data( "zone attributes", 10, data.len() - *offset, )); } zones.push(TableZone { start_col: UINT16::from_le_bytes([data[*offset], data[*offset + 1]]), start_row: UINT16::from_le_bytes([data[*offset + 2], data[*offset + 3]]), end_col: UINT16::from_le_bytes([data[*offset + 4], data[*offset + 5]]), end_row: UINT16::from_le_bytes([data[*offset + 6], data[*offset + 7]]), border_fill_id: UINT16::from_le_bytes([data[*offset + 8], data[*offset + 9]]), }); *offset += 10; } } // 속성 파싱 (표 76) / Parse attribute (Table 76) let attribute = parse_table_attribute(attribute_value); // row_count=0이거나 row_sizes가 row_count와 일치하지 않으면 빈 Vec로 초기화 / Initialize as empty Vec if row_count=0 or row_sizes doesn't match row_count // Vec의 메타데이터 손상 방지를 위해 명시적으로 빈 Vec 사용 / Use explicit empty Vec to prevent Vec metadata corruption let final_row_sizes = if row_count == 0 || row_sizes.len() != row_count as usize { Vec::new() } else { row_sizes }; let result = TableAttributes { attribute, row_count, col_count, cell_spacing, padding, row_sizes: final_row_sizes, // row_count=0이거나 row_sizes가 비어있거나 비정상적으로 크면 빈 Vec 사용 / Use empty Vec when row_count=0 or row_sizes is empty/abnormal border_fill_id, zones, }; Ok(result) } /// 표 속성의 속성 파싱 (표 76) / Parse table attribute properties (Table 76) fn parse_table_attribute(value: UINT32) -> TableAttribute { // bit 0-1: 쪽 경계에서 나눔 / bit 0-1: page break behavior let page_break = match value & 0x03 { 0 => PageBreakBehavior::NoBreak, 1 => PageBreakBehavior::BreakByCell, 2 => PageBreakBehavior::NoBreakOther, _ => PageBreakBehavior::NoBreak, }; // bit 2: 제목 줄 자동 반복 여부 / bit 2: header row auto repeat let header_row_repeat = (value & 0x04) != 0; TableAttribute { page_break, header_row_repeat, } } /// 셀 리스트 파싱 (표 79) / Parse cell list (Table 79) #[allow(dead_code)] fn parse_cell_list( data: &[u8], row_count: UINT16, col_count: UINT16, row_sizes: &[HWPUNIT16], // 각 행의 실제 셀 개수 ) -> Result<Vec<TableCell>, HwpError> { let mut cells = Vec::new(); let mut offset = 0; // 셀 개수 산정: // - 스펙/실데이터에서 row_sizes는 "각 행의 실제 셀 개수"로 사용됩니다. // - row_sizes가 유효하면(합>0) 그대로 사용하고, 없으면 row_count*col_count로 폴백합니다. let total_cells_from_row_sizes: usize = row_sizes.iter().map(|&size| size as usize).sum(); let total_cells = if total_cells_from_row_sizes > 0 { total_cells_from_row_sizes } else { row_count as usize * col_count as usize }; // ListHeader(표 65)는 문서에 6바이트로 되어 있으나, 실제 파일에서는 // [paragraph_count:2][unknown1:2][attribute:4]의 8바이트 형태가 존재합니다. // // TableCell에서는 ListHeader 바로 뒤에 CellAttributes(표 80, 26바이트)가 이어지므로, // "6바이트/8바이트" 중 어떤 레이아웃인지 실제 바이트를 보고 판별해야 오프셋이 틀어지지 않습니다. fn parse_cell_attributes_at(data: &[u8], offset: usize) -> Option<CellAttributes> { if offset + 26 > data.len() { return None; } Some(CellAttributes { col_address: UINT16::from_le_bytes([data[offset], data[offset + 1]]), row_address: UINT16::from_le_bytes([data[offset + 2], data[offset + 3]]), col_span: UINT16::from_le_bytes([data[offset + 4], data[offset + 5]]), row_span: UINT16::from_le_bytes([data[offset + 6], data[offset + 7]]), width: HWPUNIT::from(UINT32::from_le_bytes([ data[offset + 8], data[offset + 9], data[offset + 10], data[offset + 11], ])), height: HWPUNIT::from(UINT32::from_le_bytes([ data[offset + 12], data[offset + 13], data[offset + 14], data[offset + 15], ])), left_margin: HWPUNIT16::from_le_bytes([data[offset + 16], data[offset + 17]]), right_margin: HWPUNIT16::from_le_bytes([data[offset + 18], data[offset + 19]]), top_margin: HWPUNIT16::from_le_bytes([data[offset + 20], data[offset + 21]]), bottom_margin: HWPUNIT16::from_le_bytes([data[offset + 22], data[offset + 23]]), border_fill_id: UINT16::from_le_bytes([data[offset + 24], data[offset + 25]]), }) } fn is_plausible_cell_attrs( attrs: &CellAttributes, row_count: UINT16, col_count: UINT16, ) -> bool { // row/col은 테이블 범위 내여야 함 if attrs.row_address >= row_count || attrs.col_address >= col_count { return false; } // 폭/높이는 0이 아닌 것이 일반적 (0이면 오프셋 오판 가능성이 큼) if attrs.width.0 == 0 || attrs.height.0 == 0 { return false; } true } for _ in 0..total_cells { if offset >= data.len() { break; // 셀 데이터가 부족할 수 있음 / Cell data may be insufficient } // 1) ListHeader 크기(6/8) 판별 // - 우선 8바이트로 가정한 뒤, 그 다음 26바이트를 CellAttributes로 해석했을 때 값이 그럴듯하면 8 // - 아니면 6바이트로 시도 // - 둘 다 그럴듯하지 않으면(데이터 손상 등) 8을 기본으로 둠 (기존 로직과 호환) let header_len = { let mut chosen = 8usize; let try8 = parse_cell_attributes_at(data, offset + 8) .filter(|a| is_plausible_cell_attrs(a, row_count, col_count)); let try6 = parse_cell_attributes_at(data, offset + 6) .filter(|a| is_plausible_cell_attrs(a, row_count, col_count)); if try8.is_some() { chosen = 8; } else if try6.is_some() { chosen = 6; } chosen }; // 2) ListHeader 파싱 (확정된 길이만큼) if offset + header_len > data.len() { break; } let list_header = ListHeader::parse(&data[offset..offset + header_len]).map_err(|e| HwpError::from(e))?; offset += header_len; // 셀 속성 파싱 (표 80 참조) / Parse cell attributes (see Table 80) // 표 80: 전체 길이 26바이트 // UINT16(2) + UINT16(2) + UINT16(2) + UINT16(2) + HWPUNIT(4) + HWPUNIT(4) + HWPUNIT16[4](8) + UINT16(2) = 26 if offset + 26 > data.len() { return Err(HwpError::insufficient_data( "cell attributes", 26, data.len() - offset, )); } let cell_attributes = parse_cell_attributes_at(data, offset).ok_or_else(|| { HwpError::insufficient_data("cell attributes", 26, data.len().saturating_sub(offset)) })?; offset += 26; cells.push(TableCell { list_header, cell_attributes, paragraphs: Vec::new(), // 트리 구조에서 나중에 채워짐 / Will be filled from tree structure later }); } Ok(cells) }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/range_tag.rs

crates/hwp-core/src/document/bodytext/range_tag.rs

/// RangeTagInfo 구조체 / RangeTagInfo structure /// /// 스펙 문서 매핑: 표 63 - 문단의 영역 태그 / Spec mapping: Table 63 - Paragraph range tag /// 각 항목: 12바이트 use crate::error::HwpError; use crate::types::{UINT32, UINT8}; use serde::{Deserialize, Serialize}; /// 영역 태그 정보 / Range tag information #[derive(Debug, Clone, Serialize, Deserialize)] pub struct RangeTagInfo { /// 영역 시작 위치 / Range start position pub start: UINT32, /// 영역 끝 위치 / Range end position pub end: UINT32, /// 태그 종류 (상위 8비트) / Tag type (upper 8 bits) pub tag_type: UINT8, /// 태그 데이터 (하위 24비트) / Tag data (lower 24 bits) pub tag_data: UINT32, } impl RangeTagInfo { /// RangeTagInfo를 바이트 배열에서 파싱합니다. / Parse RangeTagInfo from byte array. /// /// # Arguments /// * `data` - 최소 12바이트의 데이터 / At least 12 bytes of data /// /// # Returns /// 파싱된 RangeTagInfo 구조체 / Parsed RangeTagInfo structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 12 { return Err(HwpError::insufficient_data("RangeTagInfo", 12, data.len())); } // UINT32 영역 시작 / UINT32 range start let start = UINT32::from_le_bytes([data[0], data[1], data[2], data[3]]); // UINT32 영역 끝 / UINT32 range end let end = UINT32::from_le_bytes([data[4], data[5], data[6], data[7]]); // UINT32 태그(종류 + 데이터) / UINT32 tag (type + data) // 상위 8비트가 종류, 하위 24비트가 데이터 / Upper 8 bits are type, lower 24 bits are data let tag_value = UINT32::from_le_bytes([data[8], data[9], data[10], data[11]]); let tag_type = ((tag_value >> 24) & 0xFF) as UINT8; let tag_data = tag_value & 0x00FFFFFF; Ok(RangeTagInfo { start, end, tag_type, tag_data, }) } } /// 문단의 영역 태그 리스트 / Paragraph range tag list #[derive(Debug, Clone, Default, Serialize, Deserialize)] pub struct ParaRangeTag { /// 영역 태그 정보 리스트 / Range tag information list pub tags: Vec<RangeTagInfo>, } impl ParaRangeTag { /// ParaRangeTag를 바이트 배열에서 파싱합니다. / Parse ParaRangeTag from byte array. /// /// # Arguments /// * `data` - 영역 태그 데이터 (12×n 바이트) / Range tag data (12×n bytes) /// /// # Returns /// 파싱된 ParaRangeTag 구조체 / Parsed ParaRangeTag structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() % 12 != 0 { return Err(HwpError::UnexpectedValue { field: "ParaRangeTag data length".to_string(), expected: "multiple of 12".to_string(), found: format!("{} bytes", data.len()), }); } let count = data.len() / 12; let mut tags = Vec::with_capacity(count); for i in 0..count { let offset = i * 12; let tag_data = &data[offset..offset + 12]; let tag_info = RangeTagInfo::parse(tag_data) .map_err(|e| HwpError::from(e))?; tags.push(tag_info); } Ok(ParaRangeTag { tags }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/page_border_fill.rs

crates/hwp-core/src/document/bodytext/page_border_fill.rs

/// PageBorderFill 구조체 / PageBorderFill structure /// /// 스펙 문서 매핑: 표 135 - 쪽 테두리/배경 / Spec mapping: Table 135 - Page border/fill use crate::error::HwpError; use crate::types::{HWPUNIT16, UINT16, UINT32}; use serde::{Deserialize, Serialize}; /// 쪽 테두리/배경 / Page border/fill #[derive(Debug, Clone, Serialize, Deserialize)] pub struct PageBorderFill { /// 속성 / Attributes pub attributes: PageBorderFillAttributes, /// 테두리/배경 위치 왼쪽 간격 / Left spacing pub left_spacing: HWPUNIT16, /// 테두리/배경 위치 오른쪽 간격 / Right spacing pub right_spacing: HWPUNIT16, /// 테두리/배경 위치 위쪽 간격 / Top spacing pub top_spacing: HWPUNIT16, /// 테두리/배경 위치 아래쪽 간격 / Bottom spacing pub bottom_spacing: HWPUNIT16, /// 테두리/배경 ID / Border/fill ID pub border_fill_id: UINT16, } /// 쪽 테두리/배경 속성 / Page border/fill attributes #[derive(Debug, Clone, Serialize, Deserialize)] pub struct PageBorderFillAttributes { /// 위치 기준 / Position reference pub position_reference: PositionReference, /// 머리말 포함 여부 / Include header pub include_header: bool, /// 꼬리말 포함 여부 / Include footer pub include_footer: bool, /// 채울 영역 / Fill area pub fill_area: FillArea, } /// 위치 기준 / Position reference #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum PositionReference { /// 본문 기준 / Body text reference BodyText, /// 종이 기준 / Paper reference Paper, } /// 채울 영역 / Fill area #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum FillArea { /// 종이 / Paper Paper, /// 쪽 / Page Page, /// 테두리 / Border Border, } impl PageBorderFill { /// PageBorderFill를 바이트 배열에서 파싱합니다. / Parse PageBorderFill from byte array. /// /// # Arguments /// * `data` - 최소 12바이트의 데이터 / At least 12 bytes of data /// /// # Returns /// 파싱된 PageBorderFill 구조체 / Parsed PageBorderFill structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 12 { return Err(HwpError::insufficient_data("PageBorderFill", 12, data.len())); } let mut offset = 0; // UINT 속성 (표 136 참조) / UINT attributes (see Table 136) let attribute_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 속성 파싱 (표 136) / Parse attributes (Table 136) let attributes = parse_page_border_fill_attributes(attribute_value); // HWPUNIT16 테두리/배경 위치 왼쪽 간격 / HWPUNIT16 left spacing let left_spacing = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // HWPUNIT16 테두리/배경 위치 오른쪽 간격 / HWPUNIT16 right spacing let right_spacing = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // HWPUNIT16 테두리/배경 위치 위쪽 간격 / HWPUNIT16 top spacing let top_spacing = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // HWPUNIT16 테두리/배경 위치 아래쪽 간격 / HWPUNIT16 bottom spacing let bottom_spacing = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT16 테두리/배경 ID / UINT16 border/fill ID let border_fill_id = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; Ok(PageBorderFill { attributes, left_spacing, right_spacing, top_spacing, bottom_spacing, border_fill_id, }) } } /// 쪽 테두리/배경 속성 파싱 (표 136) / Parse page border/fill attributes (Table 136) fn parse_page_border_fill_attributes(value: UINT32) -> PageBorderFillAttributes { // bit 0: 위치 기준 / bit 0: position reference // 0: 본문 기준 / 0: body text reference // 1: 종이 기준 / 1: paper reference let position_reference = if (value & 0x01) == 0 { PositionReference::BodyText } else { PositionReference::Paper }; // bit 1: 머리말 포함 여부 / bit 1: include header let include_header = (value & 0x02) != 0; // bit 2: 꼬리말 포함 여부 / bit 2: include footer let include_footer = (value & 0x04) != 0; // bit 3-4: 채울 영역 / bit 3-4: fill area // 0: 종이 / 0: paper // 1: 쪽 / 1: page // 2: 테두리 / 2: border let fill_area = match (value >> 3) & 0x03 { 0 => FillArea::Paper, 1 => FillArea::Page, 2 => FillArea::Border, _ => FillArea::Paper, // 기본값 / default }; PageBorderFillAttributes { position_reference, include_header, include_footer, fill_area, } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/video_data.rs

crates/hwp-core/src/document/bodytext/video_data.rs

/// VideoData 구조체 / VideoData structure /// /// 스펙 문서 매핑: 표 123 - 동영상 개체 속성 / Spec mapping: Table 123 - Video object attributes /// /// **구현 상태 / Implementation Status** /// - 구현 완료 / Implementation complete /// - 테스트 파일(`noori.hwp`)에 VIDEO_DATA 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain VIDEO_DATA records use crate::error::HwpError; use crate::types::{decode_utf16le, INT32, UINT16}; use serde::{Deserialize, Serialize}; /// 동영상 개체 / Video object #[derive(Debug, Clone, Serialize, Deserialize)] pub struct VideoData { /// 동영상 타입 (표 124 참조) / Video type (see Table 124) /// - 0: 로컬 동영상 / Local video /// - 1: 웹 동영상 / Web video pub video_type: INT32, /// 동영상 타입에 따른 속성 / Attributes based on video type pub video_attributes: VideoAttributes, } /// 동영상 속성 / Video attributes #[derive(Debug, Clone, Serialize, Deserialize)] #[serde(tag = "type", rename_all = "snake_case")] pub enum VideoAttributes { /// 로컬 동영상 속성 (표 125 참조) / Local video attributes (see Table 125) Local { /// 비디오 파일이 사용하는 스토리지의 BinData ID / BinData ID of storage used by video file video_bindata_id: UINT16, /// 썸네일 파일이 사용하는 스토리지의 BinData ID / BinData ID of storage used by thumbnail file thumbnail_bindata_id: UINT16, }, /// 웹 동영상 속성 (표 126 참조) / Web video attributes (see Table 126) Web { /// 웹 태그 / Web tag web_tag: String, /// 썸네일 파일이 사용하는 스토리지의 BinData ID / BinData ID of storage used by thumbnail file thumbnail_bindata_id: UINT16, }, } impl VideoData { /// VideoData를 바이트 배열에서 파싱합니다. / Parse VideoData from byte array. /// /// # Arguments /// * `data` - VideoData 데이터 (동영상 개체 속성 부분만) / VideoData data (video object attributes only) /// /// # Returns /// 파싱된 VideoData 구조체 / Parsed VideoData structure /// /// # Note /// 스펙 문서 표 122에 따르면 VIDEO_DATA는 다음 구조를 가집니다: /// - 개체 공통 속성(표 68 참조) - 가변 길이 /// - 동영상 개체 속성(표 123 참조) - 가변 길이 (4 + n 바이트) /// /// 레거시 코드(hwp.js)는 동영상 개체 속성을 파싱하지 않고 있습니다. /// According to spec Table 122, VIDEO_DATA has the following structure: /// - Object common properties (Table 68) - variable length /// - Video object attributes (Table 123) - variable length (4 + n bytes) /// /// Legacy code (hwp.js) does not parse video object attributes. /// /// **테스트 상태 / Testing Status** /// 현재 테스트 파일(`noori.hwp`)에 VIDEO_DATA 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 VIDEO_DATA 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain VIDEO_DATA records, so it has not been verified with actual files. /// If an actual HWP file contains VIDEO_DATA records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // 최소 4바이트 필요 (동영상 타입) / Need at least 4 bytes (video type) if data.len() < 4 { return Err(HwpError::insufficient_data("VideoData", 4, data.len())); } let mut offset = 0; // 표 123: 동영상 타입 (INT32, 4바이트) / Table 123: Video type (INT32, 4 bytes) let video_type = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 123: 동영상 타입에 따른 속성 파싱 / Table 123: Parse attributes based on video type let video_attributes = match video_type { 0 => { // 로컬 동영상 속성 (표 125) / Local video attributes (Table 125) if data.len() < offset + 4 { return Err(HwpError::insufficient_data( "VideoData local video attributes", 4, data.len() - offset, )); } let video_bindata_id = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let thumbnail_bindata_id = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; VideoAttributes::Local { video_bindata_id, thumbnail_bindata_id, } } 1 => { // 웹 동영상 속성 (표 126) / Web video attributes (Table 126) // 웹 태그는 가변 길이이므로, 나머지 데이터에서 썸네일 BinData ID(2바이트)를 제외한 부분이 웹 태그 // Web tag is variable length, so remaining data minus thumbnail BinData ID (2 bytes) is web tag if data.len() < offset + 2 { return Err(HwpError::insufficient_data( "VideoData web video attributes", 2, data.len() - offset, )); } // 웹 태그 길이 계산: 전체 길이 - offset - 썸네일 BinData ID(2바이트) // Calculate web tag length: total length - offset - thumbnail BinData ID (2 bytes) let web_tag_length = data.len().saturating_sub(offset + 2); if web_tag_length == 0 { return Err(HwpError::UnexpectedValue { field: "VideoData web tag length".to_string(), expected: "positive number".to_string(), found: "0".to_string(), }); } let web_tag_bytes = &data[offset..offset + web_tag_length]; let web_tag = decode_utf16le(web_tag_bytes) .map_err(|e| HwpError::EncodingError { reason: format!("Failed to decode web tag: {}", e), })?; offset += web_tag_length; let thumbnail_bindata_id = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; VideoAttributes::Web { web_tag, thumbnail_bindata_id, } } _ => { return Err(HwpError::UnexpectedValue { field: "VideoData video_type".to_string(), expected: "0 or 1".to_string(), found: video_type.to_string(), }); } }; Ok(VideoData { video_type, video_attributes, }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/mod.rs

crates/hwp-core/src/document/bodytext/mod.rs

mod char_shape; /// BodyText parsing module /// /// This module handles parsing of HWP BodyText storage. /// /// 스펙 문서 매핑: 표 2 - 본문 (BodyText 스토리지) pub mod constants; pub use constants::HwpTag; pub mod control_char; pub use control_char::{ControlChar, ControlCharPosition}; pub mod chart_data; pub mod ctrl_data; pub mod ctrl_header; pub mod eqedit; pub mod footnote_shape; pub mod form_object; pub mod line_seg; pub mod list_header; pub mod memo_list; pub mod memo_shape; pub mod page_border_fill; pub mod page_def; pub mod para_header; pub mod range_tag; pub mod record_tree; pub mod shape_component; pub mod table; pub mod video_data; pub use char_shape::{CharShapeInfo, ParaCharShape}; pub use chart_data::ChartData; pub use ctrl_data::CtrlData; pub use ctrl_header::{CtrlHeader, CtrlHeaderData, CtrlId, Margin, PageNumberPosition}; pub use eqedit::EqEdit; pub use footnote_shape::{FootnoteShape, NumberShape}; pub use form_object::FormObject; pub use line_seg::{LineSegmentInfo, ParaLineSeg}; pub use list_header::ListHeader; pub use memo_list::MemoList; pub use memo_shape::MemoShape; pub use page_border_fill::PageBorderFill; pub use page_def::{PageDef, PaperDirection}; pub use para_header::{ColumnDivideType, ControlMask, ParaHeader}; pub use range_tag::{ParaRangeTag, RangeTagInfo}; pub use shape_component::ShapeComponent; pub use shape_component::ShapeComponentArc; pub use shape_component::ShapeComponentContainer; pub use shape_component::ShapeComponentCurve; pub use shape_component::ShapeComponentEllipse; pub use shape_component::ShapeComponentLine; pub use shape_component::ShapeComponentOle; pub use shape_component::ShapeComponentPicture; pub use shape_component::ShapeComponentPolygon; pub use shape_component::ShapeComponentRectangle; pub use shape_component::ShapeComponentTextArt; pub use shape_component::ShapeComponentUnknown; pub use table::{Table, TableCell}; pub use video_data::VideoData; use crate::cfb::CfbParser; use crate::decompress::decompress_deflate; use crate::document::bodytext::ctrl_header::Caption; use crate::document::fileheader::FileHeader; use crate::error::HwpError; use crate::types::{decode_utf16le, RecordHeader, WORD}; use cfb::CompoundFile; use record_tree::RecordTreeNode; use serde::{Deserialize, Serialize}; use std::io::Cursor; /// Body text structure #[derive(Debug, Clone, Default, Serialize, Deserialize)] pub struct BodyText { /// Sections (Section0, Section1, etc.) pub sections: Vec<Section>, } /// Section structure #[derive(Debug, Clone, Default, Serialize, Deserialize)] pub struct Section { /// Section index pub index: WORD, /// Paragraphs in this section pub paragraphs: Vec<Paragraph>, } /// Paragraph structure #[derive(Debug, Clone, Default, Serialize, Deserialize)] pub struct Paragraph { /// Paragraph header (level 0 record) pub para_header: ParaHeader, /// Paragraph records (level 1 records) pub records: Vec<ParagraphRecord>, } /// Paragraph record (level 1 records) #[derive(Debug, Clone, Serialize, Deserialize)] #[serde(tag = "type", rename_all = "snake_case")] pub enum ParagraphRecord { /// 문단의 텍스트 / Paragraph text ParaText { /// 텍스트 내용 (UTF-16LE) / Text content (UTF-16LE) text: String, /// 텍스트/컨트롤 토큰 시퀀스 (표/개체 등 위치를 보존하기 위한 구조) / Text/control token sequence #[serde(skip_serializing_if = "Vec::is_empty", default)] runs: Vec<ParaTextRun>, /// 제어 문자 위치 정보 / Control character positions /// 제어 문자가 없어도 빈 배열로 표시되어 JSON에 포함됩니다 / Empty array is included in JSON even if no control characters #[serde(default)] control_char_positions: Vec<crate::document::bodytext::control_char::ControlCharPosition>, /// INLINE 제어 문자 파라미터 정보 (문자 인덱스, 파라미터) / INLINE control character parameter information (char index, parameter) /// INLINE 타입 제어 문자(FIELD_END, TITLE_MARK, TAB 등)의 파라미터를 저장합니다. /// Stores parameters for INLINE type control characters (FIELD_END, TITLE_MARK, TAB, etc.). /// 스펙 문서에 파라미터 구조가 명시되지 않았으므로 바이트 배열로 저장됩니다. /// Parameter structure is not specified in spec document, so stored as byte array. #[serde(skip_serializing_if = "Vec::is_empty", default)] inline_control_params: Vec<( usize, crate::document::bodytext::control_char::InlineControlParam, )>, }, /// 문단의 글자 모양 / Paragraph character shape ParaCharShape { /// 글자 모양 정보 리스트 / Character shape information list shapes: Vec<CharShapeInfo>, }, /// 문단의 레이아웃 / Paragraph line segment ParaLineSeg { /// 줄 세그먼트 정보 리스트 / Line segment information list segments: Vec<LineSegmentInfo>, }, /// 문단의 영역 태그 / Paragraph range tag ParaRangeTag { /// 영역 태그 정보 리스트 / Range tag information list tags: Vec<RangeTagInfo>, }, /// 컨트롤 헤더 / Control header CtrlHeader { /// 컨트롤 헤더 정보 / Control header information #[serde(flatten)] header: CtrlHeader, /// 컨트롤 헤더의 자식 레코드 (레벨 2) / Child records of control header (level 2) /// 각주/미주, 머리말/꼬리말 등의 컨트롤 헤더 내부에 PARA_HEADER가 직접 올 수 있음 /// PARA_HEADER는 Paragraph로 변환되어 paragraphs에 저장됨 /// PARA_HEADER can appear directly inside control headers like footnotes/endnotes, headers/footers, etc. /// PARA_HEADER is converted to Paragraph and stored in paragraphs #[serde(skip_serializing_if = "Vec::is_empty", default)] children: Vec<ParagraphRecord>, /// 컨트롤 헤더 내부의 문단들 (레벨 2 이상의 PARA_HEADER) / Paragraphs inside control header (PARA_HEADER at level 2 or higher) /// 각주/미주, 머리말/꼬리말 등의 컨트롤 헤더 내부에 직접 나타나는 문단들 /// Paragraphs that appear directly inside control headers like footnotes/endnotes, headers/footers, etc. #[serde(skip_serializing_if = "Vec::is_empty", default)] paragraphs: Vec<Paragraph>, }, /// 문단 리스트 헤더 / Paragraph list header ListHeader { /// 문단 리스트 헤더 정보 / Paragraph list header information header: ListHeader, /// 리스트 헤더의 자식 문단들 (레벨 3, 예: 테이블 셀 내부 문단) / Child paragraphs of list header (level 3, e.g., paragraphs inside table cell) #[serde(skip_serializing_if = "Vec::is_empty", default)] paragraphs: Vec<Paragraph>, }, /// 표 개체 / Table object Table { /// 표 개체 정보 / Table object information table: Table, }, /// 용지 설정 / Page definition PageDef { /// 용지 설정 정보 / Page definition information page_def: PageDef, }, /// 각주/미주 모양 / Footnote/endnote shape FootnoteShape { /// 각주/미주 모양 정보 / Footnote/endnote shape information footnote_shape: FootnoteShape, }, /// 쪽 테두리/배경 / Page border/fill PageBorderFill { /// 쪽 테두리/배경 정보 / Page border/fill information page_border_fill: PageBorderFill, }, /// 개체 요소 / Shape component ShapeComponent { /// 개체 요소 정보 / Shape component information shape_component: ShapeComponent, /// 개체 요소의 자식 레코드 (레벨 3, 예: SHAPE_COMPONENT_PICTURE) / Child records of shape component (level 3, e.g., SHAPE_COMPONENT_PICTURE) #[serde(skip_serializing_if = "Vec::is_empty", default)] children: Vec<ParagraphRecord>, }, /// 직선 개체 / Line shape component ShapeComponentLine { /// 직선 개체 정보 / Line shape component information shape_component_line: ShapeComponentLine, }, /// 사각형 개체 / Rectangle shape component ShapeComponentRectangle { /// 사각형 개체 정보 / Rectangle shape component information shape_component_rectangle: ShapeComponentRectangle, }, /// 타원 개체 / Ellipse shape component ShapeComponentEllipse { /// 타원 개체 정보 / Ellipse shape component information shape_component_ellipse: ShapeComponentEllipse, }, /// 호 개체 / Arc shape component ShapeComponentArc { /// 호 개체 정보 / Arc shape component information shape_component_arc: ShapeComponentArc, }, /// 다각형 개체 / Polygon shape component ShapeComponentPolygon { /// 다각형 개체 정보 / Polygon shape component information shape_component_polygon: ShapeComponentPolygon, }, /// 곡선 개체 / Curve shape component ShapeComponentCurve { /// 곡선 개체 정보 / Curve shape component information shape_component_curve: ShapeComponentCurve, }, /// OLE 개체 / OLE shape component ShapeComponentOle { /// OLE 개체 정보 / OLE shape component information shape_component_ole: ShapeComponentOle, }, /// 그림 개체 / Picture shape component ShapeComponentPicture { /// 그림 개체 정보 / Picture shape component information shape_component_picture: ShapeComponentPicture, }, /// 묶음 개체 / Container shape component ShapeComponentContainer { /// 묶음 개체 정보 / Container shape component information shape_component_container: ShapeComponentContainer, }, /// 컨트롤 임의의 데이터 / Control arbitrary data CtrlData { /// 컨트롤 임의의 데이터 정보 / Control arbitrary data information ctrl_data: CtrlData, }, /// 수식 개체 / Equation editor object EqEdit { /// 수식 개체 정보 / Equation editor object information eqedit: EqEdit, }, /// 글맵시 개체 / Text art shape component ShapeComponentTextArt { /// 글맵시 개체 정보 / Text art shape component information shape_component_textart: ShapeComponentTextArt, }, /// 양식 개체 / Form object FormObject { /// 양식 개체 정보 / Form object information form_object: FormObject, }, /// 메모 모양 / Memo shape MemoShape { /// 메모 모양 정보 / Memo shape information memo_shape: MemoShape, }, /// 메모 리스트 헤더 / Memo list header MemoList { /// 메모 리스트 헤더 정보 / Memo list header information memo_list: MemoList, }, /// 차트 데이터 / Chart data ChartData { /// 차트 데이터 정보 / Chart data information chart_data: ChartData, }, /// 비디오 데이터 / Video data VideoData { /// 비디오 데이터 정보 / Video data information video_data: VideoData, }, /// Unknown 개체 / Unknown shape component ShapeComponentUnknown { /// Unknown 개체 정보 / Unknown shape component information shape_component_unknown: ShapeComponentUnknown, }, /// 기타 레코드 / Other records Other { /// Tag ID tag_id: WORD, /// Raw data data: Vec<u8>, }, } /// ParaText의 텍스트/컨트롤 토큰 / ParaText token (text or control) #[derive(Debug, Clone, Serialize, Deserialize)] #[serde(tag = "kind", rename_all = "snake_case")] pub enum ParaTextRun { /// 일반 텍스트 조각 / Plain text chunk Text { text: String }, /// 컨트롤 토큰(표/개체 등) / Control token (table/shape object etc.) Control { /// 원본 WCHAR 인덱스 위치 / Original WCHAR index position position: usize, /// 제어 문자 코드 (0-31) / Control character code (0-31) code: u8, /// 제어 문자 이름 / Control character name name: String, /// 원본에서 차지하는 WCHAR 길이 / Size in WCHAR units in original stream size_wchars: usize, /// 표시 텍스트(파생값) / Display text (derived value) /// /// - **Source of truth가 아님**: 원본 복원/Writer에서는 `runs`의 컨트롤 정보와 문서 설정으로 재계산해야 합니다. /// - 뷰어/프리뷰 용도로만 사용하며, 불일치 시 무시될 수 있습니다. #[serde(skip_serializing_if = "Option::is_none")] display_text: Option<String>, }, } impl Section { /// Section 데이터를 파싱하여 Paragraph 리스트로 변환합니다. / Parse section data into paragraph list. /// /// 트리 구조를 먼저 파싱한 후 재귀적으로 방문하여 구조화된 데이터로 변환합니다. /// First parses the tree structure, then recursively visits it to convert to structured data. /// /// # Arguments /// * `data` - Section의 원시 바이트 데이터 / Raw byte data of section /// * `version` - 파일 버전 / File version /// /// # Returns /// 파싱된 Paragraph 리스트 / Parsed paragraph list pub fn parse_data(data: &[u8], version: u32) -> Result<Vec<Paragraph>, HwpError> { // 먼저 레코드를 트리 구조로 파싱 / First parse records into tree structure let tree = RecordTreeNode::parse_tree(data).map_err(|e| HwpError::from(e))?; // 트리를 재귀적으로 방문하여 Paragraph 리스트로 변환 / Recursively visit tree to convert to Paragraph list let mut paragraphs = Vec::new(); for child in tree.children() { if child.tag_id() == HwpTag::PARA_HEADER { paragraphs.push( Self::parse_paragraph_from_tree(child, version, data) .map_err(|e| HwpError::from(e))?, ); } } Ok(paragraphs) } /// 트리 노드에서 Paragraph를 파싱합니다. / Parse Paragraph from tree node. /// /// 문단 헤더 노드와 그 자식들을 재귀적으로 처리합니다. /// Recursively processes paragraph header node and its children. fn parse_paragraph_from_tree( node: &RecordTreeNode, version: u32, original_data: &[u8], ) -> Result<Paragraph, HwpError> { Self::parse_paragraph_from_tree_internal(node, version, original_data, false) } /// 문단 헤더 노드와 그 자식들을 재귀적으로 처리합니다 (내부 함수). /// Recursively processes paragraph header node and its children (internal function). /// `is_inside_control_header`: 컨트롤 헤더 내부의 Paragraph인지 여부 /// `is_inside_control_header`: Whether this paragraph is inside a control header fn parse_paragraph_from_tree_internal( node: &RecordTreeNode, version: u32, original_data: &[u8], is_inside_control_header: bool, ) -> Result<Paragraph, HwpError> { if node.tag_id() != HwpTag::PARA_HEADER { return Err(HwpError::UnexpectedValue { field: "Paragraph tag".to_string(), expected: format!("{}", HwpTag::PARA_HEADER), found: format!("{}", node.tag_id()), }); } let para_header = ParaHeader::parse(node.data(), version).map_err(|e| HwpError::from(e))?; let mut records = Vec::new(); // 자식들을 처리 / Process children for child in node.children() { records.push( Self::parse_record_from_tree(child, version, original_data) .map_err(|e| HwpError::from(e))?, ); } // 컨트롤 헤더 내부의 머리말/꼬리말/각주/미주 문단인 경우에만 ParaText 레코드 제거 (중복 방지, hwplib 방식) // Remove ParaText records only from header/footer/footnote/endnote paragraphs inside control headers (avoid duplication, hwplib approach) // hwplib: 컨트롤 헤더 내부의 Paragraph의 ParaText에는 ExtendChar만 포함되고, 실제 텍스트는 ControlHeader 내부의 ParagraphList에만 있음 // hwplib: ParaText in paragraphs inside control headers only contains ExtendChar, actual text is only in ControlHeader's ParagraphList // 본문 Paragraph의 경우 ParaText에 참조 텍스트("각주참조" 등)가 포함되므로 제거하지 않음 // For body paragraphs, ParaText contains reference text ("각주참조" etc.), so don't remove it if is_inside_control_header { let is_control_paragraph = records.iter().any(|record| { if let ParagraphRecord::CtrlHeader { header, .. } = record { use crate::document::bodytext::CtrlId; header.ctrl_id.as_str() == CtrlId::HEADER || header.ctrl_id.as_str() == CtrlId::FOOTER || header.ctrl_id.as_str() == CtrlId::FOOTNOTE || header.ctrl_id.as_str() == CtrlId::ENDNOTE } else { false } }); if is_control_paragraph { // ParaText 레코드만 필터링 (다른 레코드는 유지) // Filter out only ParaText records (keep other records) let before_count = records.len(); records.retain(|record| !matches!(record, ParagraphRecord::ParaText { .. })); let after_count = records.len(); if before_count != after_count { #[cfg(debug_assertions)] eprintln!("[DEBUG] Removed {} ParaText records from control paragraph (is_inside_control_header={})", before_count - after_count, is_inside_control_header); } } } else { // 본문 Paragraph의 경우 ParaText 확인 (디버그) // Check ParaText in body paragraph (debug) let para_text_count = records .iter() .filter(|record| matches!(record, ParagraphRecord::ParaText { .. })) .count(); if para_text_count > 0 { for record in &records { if let ParagraphRecord::ParaText { text, .. } = record { #[cfg(debug_assertions)] eprintln!("[DEBUG] Body paragraph ParaText: {}", text); } } } } Ok(Paragraph { para_header, records, }) } /// 트리 노드에서 ParagraphRecord를 파싱합니다. / Parse ParagraphRecord from tree node. /// /// 모든 레벨의 레코드를 재귀적으로 처리합니다. /// Recursively processes records at all levels. fn parse_record_from_tree( node: &RecordTreeNode, version: u32, original_data: &[u8], ) -> Result<ParagraphRecord, HwpError> { match node.tag_id() { HwpTag::PARA_TEXT => { let data = node.data(); // pyhwp처럼 제어 문자를 찾고 텍스트만 추출 / Find control characters and extract only text like pyhwp let mut control_char_positions = Vec::new(); let mut inline_control_params = Vec::new(); let mut cleaned_text = String::new(); let mut runs: Vec<ParaTextRun> = Vec::new(); let mut idx = 0; while idx < data.len() { // 제어 문자 찾기 (UTF-16LE 바이트 배열에서) / Find control character (in UTF-16LE byte array) let mut found_control = false; let mut control_code = 0u8; let mut control_size = 0usize; // 현재 위치에서 제어 문자 확인 (0-31 범위) / Check for control character at current position (range 0-31) if idx + 1 < data.len() { let code = data[idx] as u32; // 제어 문자는 UTF-16LE에서 하위 바이트가 0-31이고 상위 바이트가 0인 경우 / Control character is when lower byte is 0-31 and upper byte is 0 in UTF-16LE if code <= 31 && data[idx + 1] == 0 { control_code = code as u8; control_size = ControlChar::get_size_by_code(control_code) * 2; // WCHAR를 바이트로 변환 / Convert WCHAR to bytes found_control = true; } } if found_control { // 제어 문자 위치 저장 (문자 인덱스 기준) / Store control character position (based on character index) let char_idx = idx / 2; // UTF-16LE에서 문자 인덱스는 바이트 인덱스 / 2 / Character index in UTF-16LE is byte index / 2 let control_name = ControlChar::to_name(control_code); control_char_positions.push( crate::document::bodytext::control_char::ControlCharPosition { position: char_idx, code: control_code, name: control_name.clone(), }, ); runs.push(ParaTextRun::Control { position: char_idx, code: control_code, name: control_name, size_wchars: ControlChar::get_size_by_code(control_code), display_text: None, }); // INLINE 타입 제어 문자인 경우 파라미터 파싱 / Parse parameters for INLINE type control characters if ControlChar::get_size_by_code(control_code) == 8 && matches!( control_code, ControlChar::FIELD_END | ControlChar::RESERVED_5_7_START..=ControlChar::RESERVED_5_7_END | ControlChar::TITLE_MARK | ControlChar::TAB | ControlChar::RESERVED_19_20_START..=ControlChar::RESERVED_19_20_END ) { // 제어 문자 코드(2 bytes) 이후의 파라미터(12 bytes) 파싱 / Parse parameter (12 bytes) after control character code (2 bytes) if idx + 2 + 12 <= data.len() { let param_data = &data[idx + 2..idx + 2 + 12]; if let Ok(param) = crate::document::bodytext::control_char::InlineControlParam::parse(control_code, param_data) { inline_control_params.push((char_idx, param)); } } } // 텍스트로 표현 가능한 제어 문자는 텍스트에 변환된 형태로 추가 / Add convertible control characters as converted text // 단, PARA_BREAK와 LINE_BREAK는 control_char_positions에만 저장하고 텍스트에는 포함하지 않음 // However, PARA_BREAK and LINE_BREAK are only stored in control_char_positions, not added to text if ControlChar::is_convertible(control_code) { // PARA_BREAK와 LINE_BREAK는 텍스트에 추가하지 않음 (control_char_positions에만 저장) // Don't add PARA_BREAK and LINE_BREAK to text (only store in control_char_positions) if control_code != ControlChar::PARA_BREAK && control_code != ControlChar::LINE_BREAK { if let Some(text_repr) = ControlChar::to_text(control_code) { cleaned_text.push_str(text_repr); runs.push(ParaTextRun::Text { text: text_repr.to_string(), }); } } } // 제거해야 할 제어 문자는 텍스트에 추가하지 않음 / Don't add removable control characters to text idx += control_size; // 제어 문자와 파라미터 건너뛰기 / Skip control character and parameters } else { // 텍스트 부분 디코딩 / Decode text portion // 다음 제어 문자까지 또는 끝까지 / Until next control character or end let mut text_end = idx; while text_end < data.len() { if text_end + 1 < data.len() { let code = data[text_end] as u32; if code <= 31 && data[text_end + 1] == 0 { break; // 제어 문자 발견 / Control character found } } text_end += 2; // UTF-16LE는 2바이트 단위 / UTF-16LE is 2-byte units } if text_end > idx { // 텍스트 부분 디코딩 / Decode text portion let text_bytes = &data[idx..text_end]; if let Ok(text) = decode_utf16le(text_bytes) { cleaned_text.push_str(&text); if !text.is_empty() { runs.push(ParaTextRun::Text { text }); } } idx = text_end; } else { // 더 이상 처리할 데이터 없음 / No more data to process break; } } } Ok(ParagraphRecord::ParaText { text: cleaned_text, runs, control_char_positions, inline_control_params, }) } HwpTag::PARA_CHAR_SHAPE => { let para_char_shape = ParaCharShape::parse(node.data()).map_err(|e| HwpError::from(e))?; Ok(ParagraphRecord::ParaCharShape { shapes: para_char_shape.shapes, }) } HwpTag::PARA_LINE_SEG => { let para_line_seg = ParaLineSeg::parse(node.data()).map_err(|e| HwpError::from(e))?; Ok(ParagraphRecord::ParaLineSeg { segments: para_line_seg.segments, }) } HwpTag::PARA_RANGE_TAG => { let para_range_tag = ParaRangeTag::parse(node.data()).map_err(|e| HwpError::from(e))?; Ok(ParagraphRecord::ParaRangeTag { tags: para_range_tag.tags, }) } HwpTag::CTRL_HEADER => { let ctrl_header = CtrlHeader::parse(node.data()).map_err(|e| HwpError::from(e))?; // 디버그: CTRL_HEADER 파싱 시작 / Debug: Start parsing CTRL_HEADER use crate::document::bodytext::ctrl_header::CtrlId; #[cfg(debug_assertions)] eprintln!( "[DEBUG] Parsing CTRL_HEADER: ctrl_id={:?}, ctrl_id_value={}", ctrl_header.ctrl_id, ctrl_header.ctrl_id_value ); // 자식 레코드들을 재귀적으로 처리 / Recursively process child records // hwp.js: visitControlHeader에서 record.children를 모두 처리 // hwp.js: visitControlHeader processes all record.children // hwp.js: visitListHeader에서 record.parentTagID === HWPTAG_CTRL_HEADER이고 isTable(control)일 때 테이블 셀로 처리 // hwp.js: visitListHeader processes as table cell when record.parentTagID === HWPTAG_CTRL_HEADER and isTable(control) let mut children = Vec::new(); let mut table_opt: Option<crate::document::bodytext::Table> = None; let mut list_headers_for_table: Vec<( u16, u16, Vec<super::Paragraph>, Option<crate::document::bodytext::table::CellAttributes>, )> = Vec::new(); // (row_address, col_address, paragraphs, cell_attributes) // CTRL_HEADER가 테이블인지 확인 / Check if CTRL_HEADER is a table // hwp.js: CommonCtrlID.Table = makeCtrlID('t', 'b', 'l', ' ') = 0x206C6274 (little-endian: 0x74626C20) // hwp.js: CommonCtrlID.Table = makeCtrlID('t', 'b', 'l', ' ') = 0x206C6274 (little-endian: 0x74626C20) // pyhwp: CHID.TBL = 'tbl ' (바이트 리버스 후) / pyhwp: CHID.TBL = 'tbl ' (after byte reverse) let is_table = ctrl_header.ctrl_id == CtrlId::TABLE || ctrl_header.ctrl_id_value == 0x74626C20u32; let mut paragraphs = Vec::new(); // libhwp 방식: TABLE 위치를 먼저 찾아서 TABLE 이후의 LIST_HEADER는 children에 추가하지 않음 // libhwp approach: Find TABLE position first, then don't add LIST_HEADERs after TABLE to children let children_slice: Vec<_> = node.children().iter().collect(); // TABLE 이전의 LIST_HEADER를 찾아서 캡션으로 파싱 / Find LIST_HEADER before TABLE and parse as caption // hwplib과 hwp-rs 방식: 별도 레코드로 캡션 처리 / hwplib and hwp-rs approach: process caption as separate record let mut caption_opt: Option<Caption> = None; // TABLE 위치 찾기 / Find TABLE position let table_index = if is_table { children_slice .iter() .position(|child| child.tag_id() == HwpTag::TABLE) } else { None }; if is_table { if let Some(table_idx) = table_index { // TABLE 이전의 LIST_HEADER 찾기 / Find LIST_HEADER before TABLE for child in children_slice.iter().take(table_idx) { if child.tag_id() == HwpTag::LIST_HEADER { // 캡션으로 파싱 / Parse as caption use crate::document::bodytext::ctrl_header::parse_caption_from_list_header; caption_opt = parse_caption_from_list_header(child.data())?; break; // 첫 번째 LIST_HEADER만 캡션으로 처리 / Only process first LIST_HEADER as caption } } } } // CTRL_HEADER가 LIST_HEADER를 가지고 있는지 먼저 확인 (머리말/꼬리말/각주/미주의 경우) // Check if CTRL_HEADER has LIST_HEADER first (for headers/footers/footnotes/endnotes) // PARA_HEADER 처리 전에 확인하여 중복 방지 // Check before processing PARA_HEADER to avoid duplication let has_list_header = children_slice .iter() .any(|child| child.tag_id() == HwpTag::LIST_HEADER && !is_table); for (idx, child) in children_slice.iter().enumerate() { if child.tag_id() == HwpTag::TABLE { // TABLE은 별도로 처리 / TABLE is processed separately let table_data = Table::parse(child.data(), version).map_err(|e| HwpError::from(e))?;

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

true

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/list_header.rs

crates/hwp-core/src/document/bodytext/list_header.rs

/// ListHeader 구조체 / ListHeader structure /// /// 스펙 문서 매핑: 표 65 - 문단 리스트 헤더 / Spec mapping: Table 65 - Paragraph list header use crate::error::HwpError; use crate::types::{INT16, UINT32}; use serde::{Deserialize, Serialize}; /// 문단 리스트 헤더 / Paragraph list header #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ListHeader { /// 문단 수 / Paragraph count pub paragraph_count: INT16, /// 속성 (표 65-1 참조) / Attribute (see Table 65-1) pub attribute: ListHeaderAttribute, } /// 문단 리스트 헤더 속성 (표 65-1) / Paragraph list header attribute (Table 65-1) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ListHeaderAttribute { /// 텍스트 방향 / Text direction pub text_direction: TextDirection, /// 문단의 줄바꿈 / Paragraph line break pub line_break: LineBreak, /// 세로 정렬 / Vertical alignment pub vertical_align: VerticalAlign, } /// 텍스트 방향 / Text direction #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum TextDirection { /// 가로 / Horizontal Horizontal, /// 세로 / Vertical Vertical, } /// 문단의 줄바꿈 / Paragraph line break #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum LineBreak { /// 일반적인 줄바꿈 / Normal line break Normal, /// 자간을 조종하여 한 줄을 유지 / Maintain one line by adjusting character spacing MaintainOneLine, /// 내용에 따라 폭이 늘어남 / Width increases according to content ExpandByContent, } /// 세로 정렬 / Vertical alignment #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum VerticalAlign { /// 위쪽 / Top Top, /// 가운데 / Center Center, /// 아래쪽 / Bottom Bottom, } impl ListHeader { /// ListHeader를 바이트 배열에서 파싱합니다. / Parse ListHeader from byte array. /// /// # Arguments /// * `data` - 최소 6바이트의 데이터 / At least 6 bytes of data /// /// # Returns /// 파싱된 ListHeader 구조체 / Parsed ListHeader structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // 표 65에는 6바이트로 되어있지만 실제 파일/구현에서는 // - 6바이트: [paragraph_count:2][attribute:4] // - 8바이트: [paragraph_count:2][unknown1:2][attribute:4] // 변형이 존재합니다. pyhwp는 8바이트 구조를 기본으로 사용합니다. // 따라서 최소 6바이트를 허용하되, 8바이트 이상이면 8바이트 구조를 우선합니다. if data.len() < 6 { return Err(HwpError::insufficient_data("ListHeader", 6, data.len())); } // INT16 문단 수 / INT16 paragraph count let paragraph_count = INT16::from_le_bytes([data[0], data[1]]); // UINT32 속성 (표 65-1 참조) / UINT32 attribute (see Table 65-1) // 6바이트 구조: [paragraph_count:2][attribute:4] // 8바이트 구조: [paragraph_count:2][unknown1:2][attribute:4] let attribute_value = if data.len() >= 8 { UINT32::from_le_bytes([data[4], data[5], data[6], data[7]]) } else { UINT32::from_le_bytes([data[2], data[3], data[4], data[5]]) }; // 속성 파싱 (표 65-1) / Parse attribute (Table 65-1) let attribute = parse_list_header_attribute(attribute_value); Ok(ListHeader { paragraph_count, attribute, }) } } /// 문단 리스트 헤더 속성 파싱 (표 65-1) / Parse list header attribute (Table 65-1) fn parse_list_header_attribute(value: UINT32) -> ListHeaderAttribute { // bit 0-2: 텍스트 방향 / bit 0-2: text direction let text_direction = match value & 0x07 { 0 => TextDirection::Horizontal, 1 => TextDirection::Vertical, _ => TextDirection::Horizontal, }; // bit 3-4: 문단의 줄바꿈 / bit 3-4: paragraph line break let line_break = match (value >> 3) & 0x03 { 0 => LineBreak::Normal, 1 => LineBreak::MaintainOneLine, 2 => LineBreak::ExpandByContent, _ => LineBreak::Normal, }; // bit 5-6: 세로 정렬 / bit 5-6: vertical alignment let vertical_align = match (value >> 5) & 0x03 { // 스펙(표 65-1): 0=top, 1=center, 2=bottom 0 => VerticalAlign::Top, 1 => VerticalAlign::Center, 2 => VerticalAlign::Bottom, _ => VerticalAlign::Top, }; ListHeaderAttribute { text_direction, line_break, vertical_align, } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/constants.rs

crates/hwp-core/src/document/bodytext/constants.rs

/// BodyText 레코드 태그 상수 정의 / BodyText record tag constants definition /// /// 스펙 문서 매핑: 표 57 - 본문의 데이터 레코드 / Spec mapping: Table 57 - BodyText data records use crate::document::constants::HWPTAG_BEGIN; /// BodyText 태그 상수 / BodyText tag constants pub struct HwpTag; impl HwpTag { /// 문단 헤더 / Paragraph header pub const PARA_HEADER: u16 = HWPTAG_BEGIN + 50; /// 문단의 텍스트 / Paragraph text pub const PARA_TEXT: u16 = HWPTAG_BEGIN + 51; /// 문단의 글자 모양 / Paragraph character shape pub const PARA_CHAR_SHAPE: u16 = HWPTAG_BEGIN + 52; /// 문단의 레이아웃 / Paragraph line segment pub const PARA_LINE_SEG: u16 = HWPTAG_BEGIN + 53; /// 문단의 영역 태그 / Paragraph range tag pub const PARA_RANGE_TAG: u16 = HWPTAG_BEGIN + 54; /// 컨트롤 헤더 / Control header pub const CTRL_HEADER: u16 = HWPTAG_BEGIN + 55; /// 문단 리스트 헤더 / Paragraph list header pub const LIST_HEADER: u16 = HWPTAG_BEGIN + 56; /// 용지 설정 / Page definition pub const PAGE_DEF: u16 = HWPTAG_BEGIN + 57; /// 각주/미주 모양 / Footnote/endnote shape pub const FOOTNOTE_SHAPE: u16 = HWPTAG_BEGIN + 58; /// 쪽 테두리/배경 / Page border/fill pub const PAGE_BORDER_FILL: u16 = HWPTAG_BEGIN + 59; /// 개체 / Shape component pub const SHAPE_COMPONENT: u16 = HWPTAG_BEGIN + 60; /// 표 개체 / Table object pub const TABLE: u16 = HWPTAG_BEGIN + 61; /// 직선 개체 / Line shape component pub const SHAPE_COMPONENT_LINE: u16 = HWPTAG_BEGIN + 62; /// 사각형 개체 / Rectangle shape component pub const SHAPE_COMPONENT_RECTANGLE: u16 = HWPTAG_BEGIN + 63; /// 타원 개체 / Ellipse shape component pub const SHAPE_COMPONENT_ELLIPSE: u16 = HWPTAG_BEGIN + 64; /// 호 개체 / Arc shape component pub const SHAPE_COMPONENT_ARC: u16 = HWPTAG_BEGIN + 65; /// 다각형 개체 / Polygon shape component pub const SHAPE_COMPONENT_POLYGON: u16 = HWPTAG_BEGIN + 66; /// 곡선 개체 / Curve shape component pub const SHAPE_COMPONENT_CURVE: u16 = HWPTAG_BEGIN + 67; /// OLE 개체 / OLE shape component pub const SHAPE_COMPONENT_OLE: u16 = HWPTAG_BEGIN + 68; /// 그림 개체 / Picture shape component pub const SHAPE_COMPONENT_PICTURE: u16 = HWPTAG_BEGIN + 69; /// 컨테이너 개체 / Container shape component pub const SHAPE_COMPONENT_CONTAINER: u16 = HWPTAG_BEGIN + 70; /// 컨트롤 임의의 데이터 / Control arbitrary data pub const CTRL_DATA: u16 = HWPTAG_BEGIN + 71; /// 수식 개체 / Equation editor pub const EQEDIT: u16 = HWPTAG_BEGIN + 72; /// 예약 / Reserved pub const RESERVED: u16 = HWPTAG_BEGIN + 73; /// 글맵시 / Text art shape component pub const SHAPE_COMPONENT_TEXTART: u16 = HWPTAG_BEGIN + 74; /// 양식 개체 / Form object pub const FORM_OBJECT: u16 = HWPTAG_BEGIN + 75; /// 메모 모양 / Memo shape pub const MEMO_SHAPE: u16 = HWPTAG_BEGIN + 76; /// 메모 리스트 헤더 / Memo list header pub const MEMO_LIST: u16 = HWPTAG_BEGIN + 77; /// 차트 데이터 / Chart data pub const CHART_DATA: u16 = HWPTAG_BEGIN + 79; /// 비디오 데이터 / Video data pub const VIDEO_DATA: u16 = HWPTAG_BEGIN + 82; /// Unknown 개체 / Unknown shape component pub const SHAPE_COMPONENT_UNKNOWN: u16 = HWPTAG_BEGIN + 99; }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_data.rs

crates/hwp-core/src/document/bodytext/ctrl_data.rs

/// CtrlData 구조체 / CtrlData structure /// /// 스펙 문서 매핑: 표 66 - 컨트롤 임의의 데이터 / Spec mapping: Table 66 - Control arbitrary data /// /// **구현 상태 / Implementation Status** /// - 구현 완료 / Implementation complete /// - 테스트 파일(`noori.hwp`)에 CTRL_DATA 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain CTRL_DATA records use crate::document::docinfo::ParameterSet; use crate::error::HwpError; use serde::{Deserialize, Serialize}; /// 컨트롤 임의의 데이터 / Control arbitrary data #[derive(Debug, Clone, Serialize, Deserialize)] pub struct CtrlData { /// 파라미터 셋 (표 50 참조) / Parameter set (see Table 50) pub parameter_set: ParameterSet, } impl CtrlData { /// CtrlData를 바이트 배열에서 파싱합니다. / Parse CtrlData from byte array. /// /// # Arguments /// * `data` - CtrlData 데이터 / CtrlData data /// /// # Returns /// 파싱된 CtrlData 구조체 / Parsed CtrlData structure /// /// # Note /// 스펙 문서 표 66에 따르면 CTRL_DATA는 다음 구조를 가집니다: /// - Parameter Set (표 50 참조) - 가변 길이 /// /// 레거시 코드(hwp.js)는 CTRL_DATA를 파싱하지 않고 있습니다. /// According to spec Table 66, CTRL_DATA has the following structure: /// - Parameter Set (Table 50) - variable length /// /// Legacy code (hwp.js) does not parse CTRL_DATA. /// /// **테스트 상태 / Testing Status** /// 현재 테스트 파일(`noori.hwp`)에 CTRL_DATA 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 CTRL_DATA 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain CTRL_DATA records, so it has not been verified with actual files. /// If an actual HWP file contains CTRL_DATA records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.is_empty() { return Err(HwpError::InsufficientData { field: "CtrlData data".to_string(), expected: 1, actual: 0, }); } // 파라미터 셋 파싱 (표 50) / Parse parameter set (Table 50) let parameter_set = ParameterSet::parse(data) .map_err(|e| HwpError::from(e))?; Ok(CtrlData { parameter_set }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/para_header.rs

crates/hwp-core/src/document/bodytext/para_header.rs

/// ParaHeader 구조체 / ParaHeader structure /// /// 스펙 문서 매핑: 표 58 - 문단 헤더 / Spec mapping: Table 58 - Paragraph header /// Tag ID: HWPTAG_PARA_HEADER /// 전체 길이: 24바이트 (5.0.3.2 이상) / Total length: 24 bytes (5.0.3.2 and above) /// /// **레벨별 사용 / Usage by Level** /// /// - **Level 0**: 본문의 문단 헤더 (일반적인 사용) / Paragraph header in body text (normal usage) /// - `Section::parse_data`에서 처리되어 `Paragraph` 구조체의 `para_header` 필드로 저장됨 /// - Processed in `Section::parse_data` and stored in `Paragraph` struct's `para_header` field /// /// - **Level 1 이상**: 컨트롤 헤더 내부의 문단 헤더 / Paragraph header inside control header /// - 각주/미주(`fn `, `en `), 머리말/꼬리말(`head`, `foot`) 등의 컨트롤 헤더 내부에 직접 나타날 수 있음 /// - Can appear directly inside control headers like footnotes/endnotes (`fn `, `en `), headers/footers (`head`, `foot`), etc. /// - `CtrlHeader`의 children에서 처리되어 `ParagraphRecord::CtrlHeader`의 `paragraphs` 필드에 저장됨 /// - Processed in `CtrlHeader`'s children and stored in `ParagraphRecord::CtrlHeader`'s `paragraphs` field /// - 레거시 코드 참고: `legacy/ruby-hwp/lib/hwp/model.rb`의 `Footnote`, `Header`, `Footer` 등에서 /// `@ctrl_header.para_headers << para_header`로 처리됨 /// - Reference: `legacy/ruby-hwp/lib/hwp/model.rb`'s `Footnote`, `Header`, `Footer`, etc. /// where `@ctrl_header.para_headers << para_header` use crate::error::HwpError; use crate::types::{UINT16, UINT32, UINT8}; use serde::{Deserialize, Serialize}; /// Control Mask 구조체 / Control Mask structure /// /// libhwp의 HWPControlMask를 참고하여 구현 /// 각 비트는 `(UINT32)(1<<ctrich) 조합`으로, 특정 제어 문자의 존재 여부를 나타냅니다. /// Control mask structure /// /// Implemented based on libhwp's HWPControlMask /// Each bit represents `(UINT32)(1<<ctrich) combination`, indicating the presence of specific control characters. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct ControlMask { /// 원본 값 / Raw value pub value: UINT32, } impl Serialize for ControlMask { fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer, { use serde::ser::SerializeMap; let active_flags = self.active_flags(); let mut map = serializer.serialize_map(Some(2))?; map.serialize_entry("value", &self.value)?; map.serialize_entry("flags", &active_flags)?; map.end() } } impl<'de> Deserialize<'de> for ControlMask { fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de>, { // 기존 호환성: 숫자로 직렬화된 경우도 처리 / Backward compatibility: handle numeric serialization // 새로운 형식: 객체로 직렬화된 경우도 처리 / New format: handle object serialization struct ControlMaskVisitor; impl<'de> serde::de::Visitor<'de> for ControlMaskVisitor { type Value = ControlMask; fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result { formatter.write_str("control mask as u32 or object with value and flags") } // 숫자로 직렬화된 경우 (기존 형식) / Numeric serialization (old format) fn visit_u32<E>(self, value: u32) -> Result<Self::Value, E> where E: serde::de::Error, { Ok(ControlMask::new(value)) } fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E> where E: serde::de::Error, { Ok(ControlMask::new(value as u32)) } // 객체로 직렬화된 경우 (새 형식) / Object serialization (new format) fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error> where M: serde::de::MapAccess<'de>, { let mut value: Option<UINT32> = None; let mut flags: Option<Vec<String>> = None; while let Some(key) = map.next_key::<String>()? { match key.as_str() { "value" => { if value.is_some() { return Err(serde::de::Error::duplicate_field("value")); } value = Some(map.next_value()?); } "flags" => { if flags.is_some() { return Err(serde::de::Error::duplicate_field("flags")); } flags = Some(map.next_value()?); } _ => { let _ = map.next_value::<serde::de::IgnoredAny>()?; } } } let value = value.ok_or_else(|| serde::de::Error::missing_field("value"))?; // flags는 무시하고 value만 사용 (flags는 value에서 계산 가능) / Ignore flags and use only value (flags can be calculated from value) Ok(ControlMask::new(value)) } } deserializer.deserialize_any(ControlMaskVisitor) } } impl ControlMask { /// ControlMask를 생성합니다. / Create a ControlMask. pub fn new(value: UINT32) -> Self { Self { value } } /// 원본 값을 반환합니다. / Returns the raw value. pub fn value(&self) -> UINT32 { self.value } /// 비트가 설정되어 있는지 확인합니다. / Check if a bit is set. fn has_bit(&self, bit: u32) -> bool { (self.value & (1u32 << bit)) != 0 } /// 구역/단 정의 컨트롤을 가졌는지 여부 / Whether the paragraph has section/column definition control /// bit 2 (Ch 2) pub fn has_sect_col_def(&self) -> bool { self.has_bit(2) } /// 필드 시작 컨트롤을 가졌는지 여부 / Whether the paragraph has field start control /// bit 3 (Ch 3) pub fn has_field_start(&self) -> bool { self.has_bit(3) } /// 필드 끝 컨트롤을 가졌는지 여부 / Whether the paragraph has field end control /// bit 4 (Ch 4) pub fn has_field_end(&self) -> bool { self.has_bit(4) } /// Title Mark를 가졌는지 여부 / Whether the paragraph has title mark /// bit 8 (Ch 8) pub fn has_title_mark(&self) -> bool { self.has_bit(8) } /// 탭을 가졌는지 여부 / Whether the paragraph has tab /// bit 9 (Ch 9) pub fn has_tab(&self) -> bool { self.has_bit(9) } /// 강제 줄 나눔을 가졌는지 여부 / Whether the paragraph has line break /// bit 10 (Ch 10) pub fn has_line_break(&self) -> bool { self.has_bit(10) } /// 그리기 객체 또는 표 객체를 가졌는지 여부 / Whether the paragraph has drawing object or table /// bit 11 (Ch 11) pub fn has_gso_table(&self) -> bool { self.has_bit(11) } /// 문단 나누기를 가졌는지 여부 / Whether the paragraph has paragraph break /// bit 13 (Ch 13) pub fn has_para_break(&self) -> bool { self.has_bit(13) } /// 숨은 설명을 가졌는지 여부 / Whether the paragraph has hidden comment /// bit 15 (Ch 15) pub fn has_hidden_comment(&self) -> bool { self.has_bit(15) } /// 머리말 또는 꼬리말을 가졌는지 여부 / Whether the paragraph has header/footer /// bit 16 (Ch 16) pub fn has_header_footer(&self) -> bool { self.has_bit(16) } /// 각주 또는 미주를 가졌는지 여부 / Whether the paragraph has footnote/endnote /// bit 17 (Ch 17) pub fn has_footnote_endnote(&self) -> bool { self.has_bit(17) } /// 자동 번호를 가졌는지 여부 / Whether the paragraph has auto number /// bit 18 (Ch 18) pub fn has_auto_number(&self) -> bool { self.has_bit(18) } /// 페이지 컨트롤을 가졌는지 여부 / Whether the paragraph has page control /// bit 21 (Ch 21) pub fn has_page_control(&self) -> bool { self.has_bit(21) } /// 책갈피/찾아보기 표시를 가졌는지 여부 / Whether the paragraph has bookmark/index mark /// bit 22 (Ch 22) pub fn has_bookmark(&self) -> bool { self.has_bit(22) } /// 덧말/글자 겹침을 가졌는지 여부 / Whether the paragraph has additional text overlapping letter /// bit 23 (Ch 23) pub fn has_additional_text_overlapping_letter(&self) -> bool { self.has_bit(23) } /// 하이픈을 가졌는지 여부 / Whether the paragraph has hyphen /// bit 24 (Ch 24) pub fn has_hyphen(&self) -> bool { self.has_bit(24) } /// 묶음 빈칸을 가졌는지 여부 / Whether the paragraph has bundle blank /// bit 30 (Ch 30) pub fn has_bundle_blank(&self) -> bool { self.has_bit(30) } /// 고정 폭 빈칸을 가졌는지 여부 / Whether the paragraph has fixed width blank /// bit 31 (Ch 31) pub fn has_fix_width_blank(&self) -> bool { self.has_bit(31) } /// 활성화된 모든 플래그를 문자열 배열로 반환합니다. / Returns all active flags as a string array. pub fn active_flags(&self) -> Vec<&'static str> { let mut flags = Vec::new(); if self.has_sect_col_def() { flags.push("section_column_definition"); } if self.has_field_start() { flags.push("field_start"); } if self.has_field_end() { flags.push("field_end"); } if self.has_title_mark() { flags.push("title_mark"); } if self.has_tab() { flags.push("tab"); } if self.has_line_break() { flags.push("line_break"); } if self.has_gso_table() { flags.push("gso_table"); } if self.has_para_break() { flags.push("paragraph_break"); } if self.has_hidden_comment() { flags.push("hidden_comment"); } if self.has_header_footer() { flags.push("header_footer"); } if self.has_footnote_endnote() { flags.push("footnote_endnote"); } if self.has_auto_number() { flags.push("auto_number"); } if self.has_page_control() { flags.push("page_control"); } if self.has_bookmark() { flags.push("bookmark"); } if self.has_additional_text_overlapping_letter() { flags.push("additional_text_overlapping_letter"); } if self.has_hyphen() { flags.push("hyphen"); } if self.has_bundle_blank() { flags.push("bundle_blank"); } if self.has_fix_width_blank() { flags.push("fix_width_blank"); } flags } } impl From<UINT32> for ControlMask { fn from(value: UINT32) -> Self { Self::new(value) } } impl From<ControlMask> for UINT32 { fn from(mask: ControlMask) -> Self { mask.value } } /// 단 나누기 종류 / Column divide type #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum ColumnDivideType { /// 구역 나누기 / Section divide Section = 0x01, /// 다단 나누기 / Multi-column divide MultiColumn = 0x02, /// 쪽 나누기 / Page divide Page = 0x04, /// 단 나누기 / Column divide Column = 0x08, } impl ColumnDivideType { fn from_bits(bits: u8) -> Vec<Self> { let mut types = Vec::new(); if bits & 0x01 != 0 { types.push(ColumnDivideType::Section); } if bits & 0x02 != 0 { types.push(ColumnDivideType::MultiColumn); } if bits & 0x04 != 0 { types.push(ColumnDivideType::Page); } if bits & 0x08 != 0 { types.push(ColumnDivideType::Column); } types } } /// 문단 헤더 구조체 / Paragraph header structure #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ParaHeader { /// 텍스트 문자 수 / Text character count /// `if (nchars & 0x80000000) { nchars &= 0x7fffffff; }` pub text_char_count: UINT32, /// 컨트롤 마스크 / Control mask /// `(UINT32)(1<<ctrich) 조합` /// JSON 직렬화 시 value만 직렬화하여 기존 호환성 유지 / Only value is serialized in JSON to maintain backward compatibility pub control_mask: ControlMask, /// 문단 모양 아이디 참조값 / Paragraph shape ID reference pub para_shape_id: UINT16, /// 문단 스타일 아이디 참조값 / Paragraph style ID reference pub para_style_id: UINT8, /// 단 나누기 종류 / Column divide type pub column_divide_type: Vec<ColumnDivideType>, /// 글자 모양 정보 수 / Character shape info count pub char_shape_count: UINT16, /// range tag 정보 수 / Range tag info count pub range_tag_count: UINT16, /// 각 줄에 대한 align에 대한 정보 수 / Line align info count pub line_align_count: UINT16, /// 문단 Instance ID (unique ID) / Paragraph instance ID pub instance_id: UINT32, /// 변경추적 병합 문단여부 (5.0.3.2 버전 이상) / Track change merge paragraph flag (5.0.3.2 and above) pub section_merge: Option<UINT16>, } impl Default for ParaHeader { fn default() -> Self { Self { text_char_count: 0, control_mask: ControlMask::new(0), para_shape_id: 0, para_style_id: 0, column_divide_type: Vec::new(), char_shape_count: 0, range_tag_count: 0, line_align_count: 0, instance_id: 0, section_merge: None, } } } impl ParaHeader { /// ParaHeader를 바이트 배열에서 파싱합니다. / Parse ParaHeader from byte array. /// /// # Arguments /// * `data` - 최소 22바이트의 데이터 (5.0.3.2 이상은 24바이트) / At least 22 bytes of data (24 bytes for 5.0.3.2 and above) /// * `version` - 파일 버전 (5.0.3.2 이상인지 확인용) / File version (to check if 5.0.3.2 and above) /// /// # Returns /// 파싱된 ParaHeader 구조체 / Parsed ParaHeader structure pub fn parse(data: &[u8], version: u32) -> Result<Self, HwpError> { // 최소 22바이트 필요 (5.0.3.2 이상은 24바이트) / Need at least 22 bytes (24 bytes for 5.0.3.2 and above) let min_size = if version >= 0x05000302 { 24 } else { 22 }; if data.len() < min_size { return Err(HwpError::insufficient_data("ParaHeader", min_size, data.len())); } let mut offset = 0; // UINT32 text(=chars) / UINT32 text character count let mut text_char_count = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); // `if (nchars & 0x80000000) { nchars &= 0x7fffffff; }` if text_char_count & 0x80000000 != 0 { text_char_count &= 0x7fffffff; } offset += 4; // UINT32 control mask / UINT32 control mask let control_mask_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); let control_mask = ControlMask::new(control_mask_value); offset += 4; // UINT16 문단 모양 아이디 참조값 / UINT16 paragraph shape ID reference let para_shape_id = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT8 문단 스타일 아이디 참조값 / UINT8 paragraph style ID reference let para_style_id = data[offset]; offset += 1; // UINT8 단 나누기 종류 / UINT8 column divide type let column_divide_bits = data[offset]; let column_divide_type = ColumnDivideType::from_bits(column_divide_bits); offset += 1; // UINT16 글자 모양 정보 수 / UINT16 character shape info count let char_shape_count = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT16 range tag 정보 수 / UINT16 range tag info count let range_tag_count = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT16 각 줄에 대한 align에 대한 정보 수 / UINT16 line align info count let line_align_count = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT32 문단 Instance ID / UINT32 paragraph instance ID let instance_id = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // UINT16 변경추적 병합 문단여부 (5.0.3.2 버전 이상) / UINT16 track change merge paragraph flag (5.0.3.2 and above) let section_merge = if version >= 0x05000302 && data.len() >= 24 { Some(UINT16::from_le_bytes([data[offset], data[offset + 1]])) } else { None }; Ok(ParaHeader { text_char_count, control_mask, para_shape_id, para_style_id, column_divide_type, char_shape_count, range_tag_count, line_align_count, instance_id, section_merge, }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/control_char.rs

crates/hwp-core/src/document/bodytext/control_char.rs

/// Control character constants based on HWP 5.0 Specification Table 6 /// HWP 5.0 스펙 표 6 기반 제어 문자 상수 /// /// 표 6: 제어 문자 / Table 6: Control characters use crate::error::HwpError; use serde::{Deserialize, Serialize}; pub struct ControlChar; /// 제어 문자 위치 정보 / Control character position information /// /// 문단 텍스트 내에서 제어 문자의 위치와 종류를 나타냅니다. /// Represents the position and type of control characters within paragraph text. #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ControlCharPosition { /// 문자 인덱스 (텍스트 내 위치) / Character index (position in text) pub position: usize, /// 제어 문자 코드 (0-31) / Control character code (0-31) pub code: u8, /// 제어 문자 이름 (상수 이름) / Control character name (constant name) pub name: String, } /// INLINE 제어 문자 파라미터 / INLINE control character parameter /// /// JSON으로 표현 가능한 의미 있는 값만 저장합니다. /// Only stores meaningful values that can be expressed in JSON. /// /// INLINE 타입 제어 문자는 제어 문자 1 WCHAR (2 bytes) + 파라미터 6 WCHAR (12 bytes) = 총 8 WCHAR (16 bytes) /// INLINE type control characters: control char 1 WCHAR (2 bytes) + parameter 6 WCHAR (12 bytes) = total 8 WCHAR (16 bytes) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct InlineControlParam { /// TAB 제어 문자의 너비 (HWPUNIT, 1/7200인치) / Width for TAB control character (HWPUNIT, 1/7200 inch) /// TAB (0x09)의 경우 첫 4바이트를 UINT32로 읽어서 저장 / For TAB (0x09), first 4 bytes read as UINT32 #[serde(skip_serializing_if = "Option::is_none")] pub width: Option<crate::types::HWPUNIT>, /// 컨트롤 ID (4바이트 ASCII 문자열) / Control ID (4-byte ASCII string) /// 다른 INLINE 타입의 경우 첫 4바이트를 ASCII로 읽기 시도 / For other INLINE types, attempt to read first 4 bytes as ASCII /// 스펙 문서에 명시되지 않은 식별자로, 정확한 의미는 알 수 없음 / Unspecified identifier in spec document, exact meaning is unknown #[serde(skip_serializing_if = "Option::is_none")] pub chid: Option<String>, } impl InlineControlParam { /// INLINE 제어 문자 파라미터를 바이트 배열에서 파싱합니다. / Parse INLINE control character parameter from byte array. /// /// # Arguments /// * `control_code` - 제어 문자 코드 / Control character code /// * `data` - 최소 12바이트의 데이터 (제어 문자 코드 이후의 데이터) / At least 12 bytes of data (data after control character code) /// /// # Returns /// 파싱된 InlineControlParam 구조체 / Parsed InlineControlParam structure pub fn parse(control_code: u8, data: &[u8]) -> Result<Self, HwpError> { if data.len() < 12 { return Err(HwpError::insufficient_data("InlineControlParam", 12, data.len())); } let mut param = InlineControlParam { width: None, chid: None, }; if control_code == ControlChar::TAB { // TAB의 경우: 첫 4바이트를 UINT32로 읽어서 width로 저장 // For TAB: read first 4 bytes as UINT32 and store as width use crate::types::UINT32; let width_value = UINT32::from_le_bytes([data[0], data[1], data[2], data[3]]); param.width = Some(crate::types::HWPUNIT::from(width_value)); } else { // 다른 INLINE 타입의 경우: 첫 4바이트를 ASCII 문자열로 읽기 시도 // For other INLINE types: attempt to read first 4 bytes as ASCII string // 스펙 문서에 파라미터 구조가 명시되지 않아 정확한 의미를 알 수 없는 식별자 // Parameter structure not specified in spec document, exact meaning of identifier is unknown let chid_bytes = &data[0..4]; // ASCII로 읽을 수 있는지 확인 (모든 바이트가 0x20-0x7E 범위이거나 0x00) // Check if can be read as ASCII (all bytes in range 0x20-0x7E or 0x00) if chid_bytes .iter() .all(|&b| b == 0 || (b >= 0x20 && b <= 0x7E)) { let chid_str = String::from_utf8_lossy(chid_bytes) .trim_end_matches('\0') .to_string(); if !chid_str.is_empty() { param.chid = Some(chid_str); } } } Ok(param) } } impl ControlChar { // Char control characters / 문자 제어 문자 /// NULL 문자 / NULL character /// 표 6에는 명시되지 않았지만 CHAR 타입으로 처리됨 / Not specified in Table 6 but handled as CHAR type pub const NULL: u8 = 0; // Extended control characters / 확장 제어 문자 /// 예약 (1-3) / Reserved (1-3) /// 표 6에는 명시되지 않았지만 EXTENDED 타입으로 처리됨 / Not specified in Table 6 but handled as EXTENDED type pub const RESERVED_1_3_START: u8 = 1; pub const RESERVED_1_3_END: u8 = 3; // Inline control characters / 인라인 제어 문자 /// 필드 끝 / Field end pub const FIELD_END: u8 = 4; /// 예약 (5-7) / Reserved (5-7) pub const RESERVED_5_7_START: u8 = 5; pub const RESERVED_5_7_END: u8 = 7; /// title mark pub const TITLE_MARK: u8 = 8; /// 탭 / Tab pub const TAB: u8 = 9; /// 예약 (19-20) / Reserved (19-20) pub const RESERVED_19_20_START: u8 = 19; pub const RESERVED_19_20_END: u8 = 20; // Char control characters (continued) / 문자 제어 문자 (계속) /// 한 줄 끝(line break) / Line break pub const LINE_BREAK: u8 = 10; /// 문단 끝(para break) / Paragraph break pub const PARA_BREAK: u8 = 13; /// 하이픈 / Hyphen pub const HYPHEN: u8 = 24; /// 예약 (25-29) / Reserved (25-29) pub const RESERVED_25_29_START: u8 = 25; pub const RESERVED_25_29_END: u8 = 29; /// 묶음 빈칸 / Bound space pub const BOUND_SPACE: u8 = 30; /// 고정폭 빈칸 / Fixed-width space pub const FIXED_SPACE: u8 = 31; // Extended control characters / 확장 제어 문자 /// 그리기 개체/표 / Drawing object/table pub const SHAPE_OBJECT: u8 = 11; /// 예약 (12) / Reserved (12) pub const RESERVED_12: u8 = 12; /// 예약 (14) / Reserved (14) pub const RESERVED_14: u8 = 14; /// 숨은 설명 / Hidden description pub const HIDDEN_DESC: u8 = 15; /// 머리말/꼬리말 / Header/footer /// 제어 문자 코드는 16으로 동일하며, 실제 구분은 컨트롤 헤더의 컨트롤 ID로 이루어짐 ("head" = 머리말, "foot" = 꼬리말) /// Control character code is 16 for both, actual distinction is made by control ID in control header ("head" = header, "foot" = footer) pub const HEADER_FOOTER: u8 = 16; /// 각주/미주 / Footnote/endnote /// 제어 문자 코드는 17로 동일하지만, 실제 컨트롤 ID로 구분됨 ("fn " = 각주, "en " = 미주) /// Control character code is 17 for both, but distinguished by control ID ("fn " = footnote, "en " = endnote) pub const FOOTNOTE: u8 = 17; /// 자동번호(각주, 표 등) / Auto number (footnote, table, etc.) pub const AUTO_NUMBER: u8 = 18; /// 페이지 컨트롤(감추기, 새 번호로 시작 등) / Page control (hide, start new number, etc.) pub const PAGE_CONTROL: u8 = 21; /// 책갈피/찾아보기 표식 / Bookmark/find mark pub const BOOKMARK: u8 = 22; /// 덧말/글자 겹침 / Comment overlap pub const COMMENT_OVERLAP: u8 = 23; /// 변환 가능한 제어 문자인지 확인 / Check if control character can be converted /// /// 텍스트로 표현 가능한 제어 문자 (텍스트에 유지됨) / Control characters that can be expressed as text (kept in text) pub fn is_convertible(code: u8) -> bool { matches!( code, Self::TAB | Self::LINE_BREAK | Self::PARA_BREAK | Self::HYPHEN | Self::BOUND_SPACE | Self::FIXED_SPACE ) } /// 제어 문자를 텍스트 표현으로 변환 / Convert control character to text representation /// /// 변환 불가능한 경우 None 반환 / Returns None if conversion is not possible pub fn to_text(code: u8) -> Option<&'static str> { match code { Self::TAB => Some("\t"), // 탭 문자 그대로 유지 / Keep tab character as-is Self::LINE_BREAK => Some("\n"), // 한 줄 끝(line break) / Line break Self::PARA_BREAK => Some("\n"), // 문단 끝(para break) - 줄바꿈으로 표현 / Paragraph break - expressed as line break Self::HYPHEN => Some("-"), // 하이픈 / Hyphen Self::BOUND_SPACE => Some(" "), // 묶음 빈칸을 공백으로 변환 / Convert bound space to space Self::FIXED_SPACE => Some(" "), // 고정폭 빈칸을 공백으로 변환 / Convert fixed-width space to space _ => None, } } /// 제어 문자 코드를 이름으로 변환 / Convert control character code to name /// /// # Arguments /// * `code` - 제어 문자 코드 (0-31) / Control character code (0-31) /// /// # Returns /// 제어 문자 상수 이름 (예: "FOOTNOTE", "AUTO_NUMBER") / Control character constant name (e.g., "FOOTNOTE", "AUTO_NUMBER") pub fn to_name(code: u8) -> String { match code { Self::NULL => "NULL".to_string(), Self::RESERVED_1_3_START..=Self::RESERVED_1_3_END => { format!("RESERVED_{}", code) } Self::FIELD_END => "FIELD_END".to_string(), Self::RESERVED_5_7_START..=Self::RESERVED_5_7_END => { format!("RESERVED_{}", code) } Self::TITLE_MARK => "TITLE_MARK".to_string(), Self::TAB => "TAB".to_string(), Self::LINE_BREAK => "LINE_BREAK".to_string(), Self::SHAPE_OBJECT => "SHAPE_OBJECT".to_string(), Self::RESERVED_12 => "RESERVED_12".to_string(), Self::PARA_BREAK => "PARA_BREAK".to_string(), Self::RESERVED_14 => "RESERVED_14".to_string(), Self::HIDDEN_DESC => "HIDDEN_DESC".to_string(), Self::HEADER_FOOTER => "HEADER_FOOTER".to_string(), Self::FOOTNOTE => "FOOTNOTE".to_string(), Self::AUTO_NUMBER => "AUTO_NUMBER".to_string(), Self::RESERVED_19_20_START..=Self::RESERVED_19_20_END => { format!("RESERVED_{}", code) } Self::PAGE_CONTROL => "PAGE_CONTROL".to_string(), Self::BOOKMARK => "BOOKMARK".to_string(), Self::COMMENT_OVERLAP => "COMMENT_OVERLAP".to_string(), Self::HYPHEN => "HYPHEN".to_string(), Self::RESERVED_25_29_START..=Self::RESERVED_25_29_END => { format!("RESERVED_{}", code) } Self::BOUND_SPACE => "BOUND_SPACE".to_string(), Self::FIXED_SPACE => "FIXED_SPACE".to_string(), _ => format!("UNKNOWN_{}", code), } } /// 제어 문자 타입에 따른 크기 반환 (WCHAR 단위) / Get size based on control character type (in WCHAR units) /// /// CHAR: 1 WCHAR (2 bytes) /// INLINE: 8 WCHAR (16 bytes) - 제어 문자 1 + 파라미터 6 /// EXTENDED: 8 WCHAR (16 bytes) - 제어 문자 1 + 포인터 6 #[allow(clippy::if_same_then_else)] pub fn get_size_by_code(code: u8) -> usize { if code <= 31 { // CHAR 타입: 1 WCHAR (2 bytes) // 표 6 참조: 10 (LINE_BREAK), 13 (PARA_BREAK), 24 (HYPHEN), 30 (BOUND_SPACE), 31 (FIXED_SPACE) // 표 6 미명시: 0 (NULL) - CHAR 타입으로 처리 if matches!( code, Self::NULL | Self::LINE_BREAK | Self::PARA_BREAK | Self::HYPHEN | Self::BOUND_SPACE | Self::FIXED_SPACE ) { 1 } // INLINE 타입: 8 WCHAR (16 bytes) // 표 6 참조: 4 (FIELD_END), 5-7 (예약), 8 (TITLE_MARK), 9 (TAB), 19-20 (예약) else if matches!( code, Self::FIELD_END | Self::RESERVED_5_7_START..=Self::RESERVED_5_7_END | Self::TITLE_MARK | Self::TAB | Self::RESERVED_19_20_START..=Self::RESERVED_19_20_END ) { 8 } // EXTENDED 타입: 8 WCHAR (16 bytes) // 표 6 참조: 11-12, 14-18, 21-23 // 표 6 미명시: 1-3 - EXTENDED 타입으로 처리 // INLINE과 동일한 크기(8)이지만 의미적으로 다른 타입임 / Same size (8) as INLINE but semantically different type else { 8 } } else { 1 // 일반 문자 } } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/form_object.rs

crates/hwp-core/src/document/bodytext/form_object.rs

/// FormObject 구조체 / FormObject structure /// /// **구현 상태 / Implementation Status** /// - 구현 완료 / Implementation complete /// - 스펙 문서에 상세 구조가 명시되어 있지 않음 / Spec document does not specify detailed structure /// - 테스트 파일(`noori.hwp`)에 FORM_OBJECT 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain FORM_OBJECT records use crate::error::HwpError; use serde::{Deserialize, Serialize}; /// 양식 개체 / Form object #[derive(Debug, Clone, Serialize, Deserialize)] pub struct FormObject { /// Raw 데이터 / Raw data /// 스펙 문서에 상세 구조가 명시되어 있지 않으므로 raw 데이터로 저장합니다. /// Raw data is stored because the spec document does not specify detailed structure. #[serde(skip_serializing_if = "Vec::is_empty")] pub raw_data: Vec<u8>, } impl FormObject { /// FormObject을 바이트 배열에서 파싱합니다. / Parse FormObject from byte array. /// /// # Arguments /// * `data` - FormObject 데이터 / FormObject data /// /// # Returns /// 파싱된 FormObject 구조체 / Parsed FormObject structure /// /// # Note /// 스펙 문서 표 57에는 "양식 개체"로만 언급되어 있고 상세 구조가 명시되어 있지 않습니다. /// 레거시 코드(hwp.js)도 raw 데이터로만 저장하고 있습니다. /// Spec document Table 57 only mentions "Form object" and does not specify detailed structure. /// Legacy code (hwp.js) also stores only raw data. /// /// **테스트 상태 / Testing Status** /// 현재 테스트 파일(`noori.hwp`)에 FORM_OBJECT 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 FORM_OBJECT 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain FORM_OBJECT records, so it has not been verified with actual files. /// If an actual HWP file contains FORM_OBJECT records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { Ok(FormObject { raw_data: data.to_vec(), }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/chart_data.rs

crates/hwp-core/src/document/bodytext/chart_data.rs

/// ChartData 구조체 / ChartData structure /// /// **구현 상태 / Implementation Status** /// - 구현 완료 / Implementation complete /// - 스펙 문서에 상세 구조가 명시되어 있지 않음 / Spec document does not specify detailed structure /// - 테스트 파일(`noori.hwp`)에 CHART_DATA 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain CHART_DATA records use crate::error::HwpError; use serde::{Deserialize, Serialize}; /// 차트 데이터 / Chart data #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ChartData { /// Raw 데이터 / Raw data /// 스펙 문서에 상세 구조가 명시되어 있지 않으므로 raw 데이터로 저장합니다. /// Raw data is stored because the spec document does not specify detailed structure. #[serde(skip_serializing_if = "Vec::is_empty")] pub raw_data: Vec<u8>, } impl ChartData { /// ChartData를 바이트 배열에서 파싱합니다. / Parse ChartData from byte array. /// /// # Arguments /// * `data` - ChartData 데이터 / ChartData data /// /// # Returns /// 파싱된 ChartData 구조체 / Parsed ChartData structure /// /// # Note /// 스펙 문서 표 57에는 "차트 데이터"로만 언급되어 있고 상세 구조가 명시되어 있지 않습니다. /// 레거시 코드(hwp.js)도 raw 데이터로만 저장하고 있습니다. /// Spec document Table 57 only mentions "Chart data" and does not specify detailed structure. /// Legacy code (hwp.js) also stores only raw data. /// /// **테스트 상태 / Testing Status** /// 현재 테스트 파일(`noori.hwp`)에 CHART_DATA 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 CHART_DATA 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain CHART_DATA records, so it has not been verified with actual files. /// If an actual HWP file contains CHART_DATA records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { Ok(ChartData { raw_data: data.to_vec(), }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/shape_component/ole.rs

crates/hwp-core/src/document/bodytext/shape_component/ole.rs

/// ShapeComponentOle 구조체 / ShapeComponentOle structure /// /// 스펙 문서 매핑: 표 118 - OLE 개체 속성 / Spec mapping: Table 118 - OLE shape component attributes /// /// **구현 상태 / Implementation Status** /// - 구현 완료 / Implementation complete /// - 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_OLE 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain SHAPE_COMPONENT_OLE records use crate::error::HwpError; use crate::types::{COLORREF, INT32, UINT16, UINT32}; use serde::{Deserialize, Serialize}; /// OLE 개체 / OLE shape component #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ShapeComponentOle { /// 속성 / Attributes (표 119 참조 / See Table 119) pub attributes: OleAttributes, /// 오브젝트 자체의 extent x크기 / Object extent X size pub extent_x: INT32, /// 오브젝트 자체의 extent y크기 / Object extent Y size pub extent_y: INT32, /// 오브젝트가 사용하는 스토리지의 BinData ID / BinData ID of storage used by object pub bindata_id: UINT16, /// 테두리 색 / Border color pub border_color: COLORREF, /// 테두리 두께 / Border width pub border_width: INT32, /// 테두리 속성 / Border attributes (표 87 참조 / See Table 87) pub border_attributes: UINT32, } /// OLE 개체 속성 / OLE shape component attributes #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct OleAttributes { /// Drawing aspect (bit 0-7) /// - DVASPECT_CONTENT = 1 /// - DVASPECT_THUMBNAIL = 2 /// - DVASPECT_ICON = 4 /// - DVASPECT_DOCPRINT = 8 /// 자세한 설명은 MSDN의 MFC COleClientItem::m_nDrawAspect 참고 /// See MSDN MFC COleClientItem::m_nDrawAspect for details pub drawing_aspect: u8, /// TRUE if moniker is assigned (bit 8) /// 자세한 설명은 MSDN의 MFC COleClientItem::m_bMoniker 참고 /// See MSDN MFC COleClientItem::m_bMoniker for details pub has_moniker: bool, /// 베이스라인 (bit 9-15) /// 0은 기본값(85%), 1-101은 0-100%를 나타냄. 현재는 수식만 별도의 베이스라인을 가짐 /// 0 is default (85%), 1-101 represents 0-100%. Currently only equations have separate baseline pub baseline: u8, /// 개체 종류 (bit 16-21) / Object type /// - 0: Unknown /// - 1: Embedded /// - 2: Link /// - 3: Static /// - 4: Equation pub object_type: u8, } impl ShapeComponentOle { /// ShapeComponentOle을 바이트 배열에서 파싱합니다. / Parse ShapeComponentOle from byte array. /// /// # Arguments /// * `data` - ShapeComponentOle 데이터 (OLE 개체 속성 부분만) / ShapeComponentOle data (OLE shape component attributes only) /// /// # Returns /// 파싱된 ShapeComponentOle 구조체 / Parsed ShapeComponentOle structure /// /// # Note /// 스펙 문서 표 117에 따르면 SHAPE_COMPONENT_OLE은 다음 구조를 가집니다: /// - 개체 공통 속성(표 68 참조) - 가변 길이 /// - OLE 개체 속성(표 118 참조) - 24바이트 /// /// 레거시 코드(hwp.js)는 OLE 개체 속성을 파싱하지 않고 있습니다. /// According to spec Table 117, SHAPE_COMPONENT_OLE has the following structure: /// - Object common properties (Table 68) - variable length /// - OLE shape component attributes (Table 118) - 24 bytes /// /// Legacy code (hwp.js) does not parse OLE shape component attributes. /// /// **테스트 상태 / Testing Status** /// 현재 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_OLE 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 SHAPE_COMPONENT_OLE 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain SHAPE_COMPONENT_OLE records, so it has not been verified with actual files. /// If an actual HWP file contains SHAPE_COMPONENT_OLE records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // 표 118: OLE 개체 속성은 24바이트 / Table 118: OLE shape component attributes is 24 bytes // UINT16(2) + INT32(4) + INT32(4) + UINT16(2) + COLORREF(4) + INT32(4) + UINT32(4) = 24 bytes if data.len() < 24 { return Err(HwpError::insufficient_data("ShapeComponentOle", 24, data.len())); } let mut offset = 0; // 표 118: 속성 (UINT16, 2바이트) / Table 118: Attributes (UINT16, 2 bytes) let attr_value = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // 표 119: 속성 비트 필드 파싱 / Table 119: Parse attribute bit fields // Note: UINT16 is 16 bits, so bits 16-21 don't exist in this field // 참고: UINT16은 16비트이므로 bit 16-21은 이 필드에 존재하지 않습니다 let drawing_aspect = (attr_value & 0xFF) as u8; // bit 0-7 let has_moniker = (attr_value & 0x100) != 0; // bit 8 let baseline = ((attr_value >> 9) & 0x7F) as u8; // bit 9-15 // object_type is not in UINT16 field, will be read from later data if needed // object_type은 UINT16 필드에 없으며, 필요시 이후 데이터에서 읽습니다 let object_type = 0u8; // Placeholder - may need to read from additional data // 표 118: 오브젝트 자체의 extent x크기 (INT32, 4바이트) / Table 118: Object extent X size (INT32, 4 bytes) let extent_x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 118: 오브젝트 자체의 extent y크기 (INT32, 4바이트) / Table 118: Object extent Y size (INT32, 4 bytes) let extent_y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 118: 오브젝트가 사용하는 스토리지의 BinData ID (UINT16, 2바이트) / Table 118: BinData ID (UINT16, 2 bytes) let bindata_id = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // 표 118: 테두리 색 (COLORREF, 4바이트) / Table 118: Border color (COLORREF, 4 bytes) let border_color_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); let border_color = COLORREF(border_color_value); offset += 4; // 표 118: 테두리 두께 (INT32, 4바이트) / Table 118: Border width (INT32, 4 bytes) let border_width = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 118: 테두리 속성 (UINT32, 4바이트) / Table 118: Border attributes (UINT32, 4 bytes) let border_attributes = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); Ok(ShapeComponentOle { attributes: OleAttributes { drawing_aspect, has_moniker, baseline, object_type, }, extent_x, extent_y, bindata_id, border_color, border_width, border_attributes, }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/shape_component/picture.rs

crates/hwp-core/src/document/bodytext/shape_component/picture.rs

/// ShapeComponentPicture 구조체 / ShapeComponentPicture structure /// /// 스펙 문서 매핑: 표 107 - 그림 개체 속성 / Spec mapping: Table 107 - Picture shape component attributes /// /// **구현 상태 / Implementation Status** /// - 구현 완료 / Implementation complete /// - 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_PICTURE 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain SHAPE_COMPONENT_PICTURE records use crate::error::HwpError; use crate::types::{COLORREF, HWPUNIT16, INT32, INT8, UINT16, UINT32}; use serde::{Deserialize, Serialize}; /// 그림 개체 / Picture shape component #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ShapeComponentPicture { /// 테두리 색 / Border color pub border_color: COLORREF, /// 테두리 두께 / Border width pub border_width: INT32, /// 테두리 속성 / Border attributes (표 87 참조 / See Table 87) pub border_attributes: UINT32, /// 이미지의 테두리 사각형의 x 좌표 / X coordinates of image border rectangle (최초 그림 삽입 시 크기 / size at initial picture insertion) pub border_rectangle_x: RectangleCoordinates, /// 이미지의 테두리 사각형의 y 좌표 / Y coordinates of image border rectangle (최초 그림 삽입 시 크기 / size at initial picture insertion) pub border_rectangle_y: RectangleCoordinates, /// 자르기 한 후 사각형 / Cropped rectangle pub crop_rectangle: CropRectangle, /// 안쪽 여백 정보 / Inner padding information (표 77 참조 / See Table 77) pub padding: Padding, /// 그림 정보 / Picture information (표 32 참조 / See Table 32) pub picture_info: PictureInfo, /// 테두리 투명도 / Border opacity pub border_opacity: u8, /// 문서 내 각 개체에 대한 고유 아이디(instance ID) / Unique ID (instance ID) for each object in document pub instance_id: UINT32, /// 그림 효과 정보 / Picture effect information (표 108 참조 / See Table 108) /// 가변 길이이므로 raw 데이터로 저장 / Variable length, stored as raw data #[serde(skip_serializing_if = "Vec::is_empty")] pub effect_data: Vec<u8>, } /// 사각형 좌표 / Rectangle coordinates #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct RectangleCoordinates { /// 왼쪽 / Left pub left: INT32, /// 위쪽 / Top pub top: INT32, /// 오른쪽 / Right pub right: INT32, /// 아래쪽 / Bottom pub bottom: INT32, } /// 자르기 사각형 / Crop rectangle #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct CropRectangle { /// 왼쪽 / Left pub left: INT32, /// 위쪽 / Top pub top: INT32, /// 오른쪽 / Right pub right: INT32, /// 아래쪽 / Bottom pub bottom: INT32, } /// 안쪽 여백 정보 / Inner padding information #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct Padding { /// 왼쪽 여백 / Left padding pub left: HWPUNIT16, /// 오른쪽 여백 / Right padding pub right: HWPUNIT16, /// 위쪽 여백 / Top padding pub top: HWPUNIT16, /// 아래쪽 여백 / Bottom padding pub bottom: HWPUNIT16, } /// 그림 정보 / Picture information #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct PictureInfo { /// 밝기 / Brightness pub brightness: INT8, /// 명암 / Contrast pub contrast: INT8, /// 그림 효과 / Picture effect /// - 0: REAL_PIC /// - 1: GRAY_SCALE /// - 2: BLACK_WHITE /// - 4: PATTERN8x8 pub effect: u8, /// BinItem의 아이디 참조값 / BinItem ID reference pub bindata_id: UINT16, } impl ShapeComponentPicture { /// ShapeComponentPicture을 바이트 배열에서 파싱합니다. / Parse ShapeComponentPicture from byte array. /// /// # Arguments /// * `data` - ShapeComponentPicture 데이터 (그림 개체 속성 부분만) / ShapeComponentPicture data (picture shape component attributes only) /// /// # Returns /// 파싱된 ShapeComponentPicture 구조체 / Parsed ShapeComponentPicture structure /// /// # Note /// 스펙 문서 표 106에 따르면 SHAPE_COMPONENT_PICTURE은 다음 구조를 가집니다: /// - 개체 공통 속성(표 68 참조) - 가변 길이 /// - 개체 요소 공통 속성(표 83 참조) - 가변 길이 /// - 그림 개체 속성(표 107 참조) - 가변 길이 (78 + n 바이트) /// /// 레거시 코드(hwp.js)는 그림 개체 속성의 일부만 파싱하고 있습니다. /// According to spec Table 106, SHAPE_COMPONENT_PICTURE has the following structure: /// - Object common properties (Table 68) - variable length /// - Object element common properties (Table 83) - variable length /// - Picture shape component attributes (Table 107) - variable length (78 + n bytes) /// /// Legacy code (hwp.js) only parses part of picture shape component attributes. /// /// **테스트 상태 / Testing Status** /// 현재 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_PICTURE 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 SHAPE_COMPONENT_PICTURE 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain SHAPE_COMPONENT_PICTURE records, so it has not been verified with actual files. /// If an actual HWP file contains SHAPE_COMPONENT_PICTURE records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { let mut offset = 0; // 그림 개체 속성(표 107) 파싱 시작 / Start parsing picture shape component attributes (Table 107) // 최소 78바이트 필요 (고정 부분) / Need at least 78 bytes (fixed part) if data.len() < 78 { return Err(HwpError::insufficient_data("ShapeComponentPicture", 78, data.len())); } // 표 107: 테두리 색 (COLORREF, 4바이트) / Table 107: Border color (COLORREF, 4 bytes) let border_color_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); let border_color = COLORREF(border_color_value); offset += 4; // 표 107: 테두리 두께 (INT32, 4바이트) / Table 107: Border width (INT32, 4 bytes) let border_width = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 107: 테두리 속성 (UINT32, 4바이트) / Table 107: Border attributes (UINT32, 4 bytes) let border_attributes = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 107: 이미지의 테두리 사각형의 x 좌표 (INT32 array[4], 16바이트) / Table 107: X coordinates of image border rectangle (INT32 array[4], 16 bytes) let border_x_left = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let border_x_top = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let border_x_right = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let border_x_bottom = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 107: 이미지의 테두리 사각형의 y 좌표 (INT32 array[4], 16바이트) / Table 107: Y coordinates of image border rectangle (INT32 array[4], 16 bytes) let border_y_left = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let border_y_top = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let border_y_right = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let border_y_bottom = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 107: 자르기 한 후 사각형의 left (INT32, 4바이트) / Table 107: Cropped rectangle left (INT32, 4 bytes) let crop_left = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 107: 자르기 한 후 사각형의 top (INT32, 4바이트) / Table 107: Cropped rectangle top (INT32, 4 bytes) let crop_top = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 107: 자르기 한 후 사각형의 right (INT32, 4바이트) / Table 107: Cropped rectangle right (INT32, 4 bytes) let crop_right = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 107: 자르기 한 후 사각형의 bottom (INT32, 4바이트) / Table 107: Cropped rectangle bottom (INT32, 4 bytes) let crop_bottom = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 107: 안쪽 여백 정보 (표 77 참조, 8바이트) / Table 107: Inner padding information (Table 77, 8 bytes) let padding_left = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let padding_right = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let padding_top = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let padding_bottom = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // 표 107: 그림 정보 (표 32 참조, 5바이트) / Table 107: Picture information (Table 32, 5 bytes) let brightness = data[offset] as i8; offset += 1; let contrast = data[offset] as i8; offset += 1; let effect = data[offset]; offset += 1; let bindata_id = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // 표 107: 테두리 투명도 (BYTE, 1바이트) / Table 107: Border opacity (BYTE, 1 byte) let border_opacity = data[offset]; offset += 1; // 표 107: 문서 내 각 개체에 대한 고유 아이디(instance ID) (UINT32, 4바이트) / Table 107: Instance ID (UINT32, 4 bytes) let instance_id = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 107: 그림 효과 정보 (표 108 참조, 가변 길이) / Table 107: Picture effect information (Table 108, variable length) let effect_data = if offset < data.len() { data[offset..].to_vec() } else { Vec::new() }; Ok(ShapeComponentPicture { border_color, border_width, border_attributes, border_rectangle_x: RectangleCoordinates { left: border_x_left, top: border_x_top, right: border_x_right, bottom: border_x_bottom, }, border_rectangle_y: RectangleCoordinates { left: border_y_left, top: border_y_top, right: border_y_right, bottom: border_y_bottom, }, crop_rectangle: CropRectangle { left: crop_left, top: crop_top, right: crop_right, bottom: crop_bottom, }, padding: Padding { left: padding_left, right: padding_right, top: padding_top, bottom: padding_bottom, }, picture_info: PictureInfo { brightness, contrast, effect, bindata_id, }, border_opacity, instance_id, effect_data, }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/shape_component/unknown.rs

crates/hwp-core/src/document/bodytext/shape_component/unknown.rs

/// ShapeComponentUnknown 구조체 / ShapeComponentUnknown structure /// /// 스펙 문서 매핑: 표 57 - Unknown (36바이트) / Spec mapping: Table 57 - Unknown (36 bytes) /// /// **구현 상태 / Implementation Status** /// - 구현 완료 / Implementation complete /// - 스펙 문서에 상세 구조가 명시되어 있지 않음 / Spec document does not specify detailed structure /// - 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_UNKNOWN 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain SHAPE_COMPONENT_UNKNOWN records use crate::error::HwpError; use serde::{Deserialize, Serialize}; /// Unknown 개체 / Unknown shape component #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ShapeComponentUnknown { /// Raw 데이터 / Raw data /// 스펙 문서에 상세 구조가 명시되어 있지 않으므로 raw 데이터로 저장합니다. /// 스펙 문서 표 57에는 36바이트로 정의되어 있습니다. /// Raw data is stored because the spec document does not specify detailed structure. /// Spec document Table 57 defines it as 36 bytes. #[serde(skip_serializing_if = "Vec::is_empty")] pub raw_data: Vec<u8>, } impl ShapeComponentUnknown { /// ShapeComponentUnknown을 바이트 배열에서 파싱합니다. / Parse ShapeComponentUnknown from byte array. /// /// # Arguments /// * `data` - ShapeComponentUnknown 데이터 / ShapeComponentUnknown data /// /// # Returns /// 파싱된 ShapeComponentUnknown 구조체 / Parsed ShapeComponentUnknown structure /// /// # Note /// 스펙 문서 표 57에는 "Unknown"으로만 언급되어 있고 상세 구조가 명시되어 있지 않습니다. /// 스펙 문서에는 36바이트로 정의되어 있지만, 실제 파일에서는 다를 수 있습니다. /// 레거시 코드(hwp.js)도 raw 데이터로만 저장하고 있습니다. /// Spec document Table 57 only mentions "Unknown" and does not specify detailed structure. /// Spec document defines it as 36 bytes, but actual files may differ. /// Legacy code (hwp.js) also stores only raw data. /// /// **테스트 상태 / Testing Status** /// 현재 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_UNKNOWN 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 SHAPE_COMPONENT_UNKNOWN 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain SHAPE_COMPONENT_UNKNOWN records, so it has not been verified with actual files. /// If an actual HWP file contains SHAPE_COMPONENT_UNKNOWN records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { Ok(ShapeComponentUnknown { raw_data: data.to_vec(), }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/shape_component/textart.rs

crates/hwp-core/src/document/bodytext/shape_component/textart.rs

/// ShapeComponentTextArt 구조체 / ShapeComponentTextArt structure /// /// **구현 상태 / Implementation Status** /// - 구현 완료 / Implementation complete /// - 스펙 문서에 상세 구조가 명시되어 있지 않음 / Spec document does not specify detailed structure /// - 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_TEXTART 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain SHAPE_COMPONENT_TEXTART records use crate::error::HwpError; use serde::{Deserialize, Serialize}; /// 글맵시 개체 / Text art shape component #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ShapeComponentTextArt { /// Raw 데이터 / Raw data /// 스펙 문서에 상세 구조가 명시되어 있지 않으므로 raw 데이터로 저장합니다. /// Raw data is stored because the spec document does not specify detailed structure. #[serde(skip_serializing_if = "Vec::is_empty")] pub raw_data: Vec<u8>, } impl ShapeComponentTextArt { /// ShapeComponentTextArt을 바이트 배열에서 파싱합니다. / Parse ShapeComponentTextArt from byte array. /// /// # Arguments /// * `data` - ShapeComponentTextArt 데이터 / ShapeComponentTextArt data /// /// # Returns /// 파싱된 ShapeComponentTextArt 구조체 / Parsed ShapeComponentTextArt structure /// /// # Note /// 스펙 문서 표 57에는 "글맵시"로만 언급되어 있고 상세 구조가 명시되어 있지 않습니다. /// 레거시 코드(hwp.js)도 raw 데이터로만 저장하고 있습니다. /// Spec document Table 57 only mentions "Text art" and does not specify detailed structure. /// Legacy code (hwp.js) also stores only raw data. /// /// **테스트 상태 / Testing Status** /// 현재 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_TEXTART 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 SHAPE_COMPONENT_TEXTART 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain SHAPE_COMPONENT_TEXTART records, so it has not been verified with actual files. /// If an actual HWP file contains SHAPE_COMPONENT_TEXTART records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { Ok(ShapeComponentTextArt { raw_data: data.to_vec(), }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/shape_component/container.rs

crates/hwp-core/src/document/bodytext/shape_component/container.rs

/// ShapeComponentContainer 구조체 / ShapeComponentContainer structure /// /// 스펙 문서 매핑: 표 121 - 묶음 개체 속성 / Spec mapping: Table 121 - Container shape component attributes /// /// **구현 상태 / Implementation Status** /// - 구현 완료 / Implementation complete /// - 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_CONTAINER 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain SHAPE_COMPONENT_CONTAINER records use crate::error::HwpError; use crate::types::{UINT16, UINT32}; use serde::{Deserialize, Serialize}; /// 묶음 개체 / Container shape component #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ShapeComponentContainer { /// 개체의 개수 / Number of objects pub object_count: UINT16, /// 개체의 컨트롤 ID 배열 / Control ID array of objects pub control_ids: Vec<UINT32>, } impl ShapeComponentContainer { /// ShapeComponentContainer을 바이트 배열에서 파싱합니다. / Parse ShapeComponentContainer from byte array. /// /// # Arguments /// * `data` - ShapeComponentContainer 데이터 (묶음 개체 속성 부분만) / ShapeComponentContainer data (container shape component attributes only) /// /// # Returns /// 파싱된 ShapeComponentContainer 구조체 / Parsed ShapeComponentContainer structure /// /// # Note /// 스펙 문서 표 120에 따르면 SHAPE_COMPONENT_CONTAINER은 다음 구조를 가집니다: /// - 개체 공통 속성(표 68 참조) - 가변 길이 /// - 묶음 개체 속성(표 121 참조) - 가변 길이 (2 + 4×n 바이트) /// - 개체 속성 x 묶음 개체의 갯수 - 가변 길이 /// /// 레거시 코드(hwp.js)는 묶음 개체 속성을 파싱하지 않고 있습니다. /// According to spec Table 120, SHAPE_COMPONENT_CONTAINER has the following structure: /// - Object common properties (Table 68) - variable length /// - Container shape component attributes (Table 121) - variable length (2 + 4×n bytes) /// - Object properties × number of container objects - variable length /// /// Legacy code (hwp.js) does not parse container shape component attributes. /// /// **테스트 상태 / Testing Status** /// 현재 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_CONTAINER 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 SHAPE_COMPONENT_CONTAINER 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain SHAPE_COMPONENT_CONTAINER records, so it has not been verified with actual files. /// If an actual HWP file contains SHAPE_COMPONENT_CONTAINER records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // 최소 2바이트 필요 (개체의 개수) / Need at least 2 bytes (object count) if data.len() < 2 { return Err(HwpError::insufficient_data("ShapeComponentContainer", 2, data.len())); } let mut offset = 0; // 표 121: 개체의 개수 (WORD, 2바이트) / Table 121: Number of objects (WORD, 2 bytes) let object_count = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let object_count_usize = object_count as usize; // 필요한 바이트 수 계산 / Calculate required bytes // WORD(2) + UINT32 array[n](4×n) = 2 + 4×n let required_bytes = 2 + 4 * object_count_usize; if data.len() < required_bytes { return Err(HwpError::InsufficientData { field: format!("ShapeComponentContainer (object_count={})", object_count_usize), expected: required_bytes, actual: data.len(), }); } // 표 121: 개체의 컨트롤 ID 배열 (UINT32 array[n], 4×n 바이트) / Table 121: Control ID array (UINT32 array[n], 4×n bytes) let mut control_ids = Vec::with_capacity(object_count_usize); for _ in 0..object_count_usize { let control_id = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); control_ids.push(control_id); offset += 4; } Ok(ShapeComponentContainer { object_count, control_ids, }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/shape_component/rectangle.rs

crates/hwp-core/src/document/bodytext/shape_component/rectangle.rs

/// ShapeComponentRectangle 구조체 / ShapeComponentRectangle structure /// /// 스펙 문서 매핑: 표 94 - 사각형 개체 속성 / Spec mapping: Table 94 - Rectangle shape component attributes /// /// **구현 상태 / Implementation Status** /// - 구현 완료 / Implementation complete /// - 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_RECTANGLE 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain SHAPE_COMPONENT_RECTANGLE records use crate::error::HwpError; use crate::types::INT32; use serde::{Deserialize, Serialize}; /// 사각형 개체 / Rectangle shape component #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ShapeComponentRectangle { /// 사각형 모서리 곡률(%) / Rectangle corner curvature (%) /// 직각은 0, 둥근 모양은 20, 반원은 50, 그 외는 적당한 값을 % 단위로 사용한다. /// Right angle is 0, rounded shape is 20, semicircle is 50, others use appropriate values in %. pub corner_curvature: u8, /// 사각형의 좌표(x) / Rectangle coordinates (x) pub x_coordinates: RectangleCoordinates, /// 사각형의 좌표(y) / Rectangle coordinates (y) pub y_coordinates: RectangleCoordinates, } /// 사각형 좌표 / Rectangle coordinates #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct RectangleCoordinates { /// 상단 / Top pub top: INT32, /// 오른쪽 / Right pub right: INT32, /// 하단 / Bottom pub bottom: INT32, /// 왼쪽 / Left pub left: INT32, } impl ShapeComponentRectangle { /// ShapeComponentRectangle을 바이트 배열에서 파싱합니다. / Parse ShapeComponentRectangle from byte array. /// /// # Arguments /// * `data` - ShapeComponentRectangle 데이터 (사각형 개체 속성 부분만) / ShapeComponentRectangle data (rectangle shape component attributes only) /// /// # Returns /// 파싱된 ShapeComponentRectangle 구조체 / Parsed ShapeComponentRectangle structure /// /// # Note /// 스펙 문서 표 93에 따르면 SHAPE_COMPONENT_RECTANGLE은 다음 구조를 가집니다: /// - 개체 공통 속성(표 68 참조) - 가변 길이 /// - 그리기 개체 공통 속성(표 81 참조) - 가변 길이 /// - 사각형 개체 속성(표 94 참조) - 33바이트 /// /// 레거시 코드(hwp.js)는 사각형 개체 속성 부분만 파싱하고 있습니다. /// According to spec Table 93, SHAPE_COMPONENT_RECTANGLE has the following structure: /// - Object common properties (Table 68) - variable length /// - Drawing object common properties (Table 81) - variable length /// - Rectangle shape component attributes (Table 94) - 33 bytes /// /// Legacy code (hwp.js) only parses the rectangle shape component attributes part. /// /// **테스트 상태 / Testing Status** /// 현재 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_RECTANGLE 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 SHAPE_COMPONENT_RECTANGLE 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain SHAPE_COMPONENT_RECTANGLE records, so it has not been verified with actual files. /// If an actual HWP file contains SHAPE_COMPONENT_RECTANGLE records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // 표 94: 사각형 개체 속성은 33바이트 / Table 94: Rectangle shape component attributes is 33 bytes // BYTE(1) + INT32 array[4](16) + INT32 array[4](16) = 33 bytes if data.len() < 33 { return Err(HwpError::insufficient_data("ShapeComponentRectangle", 33, data.len())); } let mut offset = 0; // 표 94: 사각형 모서리 곡률(%) (BYTE, 1바이트) / Table 94: Rectangle corner curvature (%) (BYTE, 1 byte) let corner_curvature = data[offset]; offset += 1; // 표 94: 사각형의 좌표(x) (INT32 array[4], 16바이트) / Table 94: Rectangle coordinates (x) (INT32 array[4], 16 bytes) let x_top = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let x_right = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let x_bottom = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let x_left = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 94: 사각형의 좌표(y) (INT32 array[4], 16바이트) / Table 94: Rectangle coordinates (y) (INT32 array[4], 16 bytes) let y_top = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let y_right = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let y_bottom = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let y_left = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); Ok(ShapeComponentRectangle { corner_curvature, x_coordinates: RectangleCoordinates { top: x_top, right: x_right, bottom: x_bottom, left: x_left, }, y_coordinates: RectangleCoordinates { top: y_top, right: y_right, bottom: y_bottom, left: y_left, }, }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/shape_component/curve.rs

crates/hwp-core/src/document/bodytext/shape_component/curve.rs

/// ShapeComponentCurve 구조체 / ShapeComponentCurve structure /// /// 스펙 문서 매핑: 표 103 - 곡선 개체 속성 / Spec mapping: Table 103 - Curve shape component attributes /// /// **구현 상태 / Implementation Status** /// - 구현 완료 / Implementation complete /// - 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_CURVE 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain SHAPE_COMPONENT_CURVE records use crate::error::HwpError; use crate::types::{INT16, INT32}; use serde::{Deserialize, Serialize}; /// 곡선 개체 / Curve shape component #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ShapeComponentCurve { /// 점의 개수 / Count of points pub point_count: INT16, /// X 좌표 배열 / X coordinates array pub x_coordinates: Vec<INT32>, /// Y 좌표 배열 / Y coordinates array pub y_coordinates: Vec<INT32>, /// 세그먼트 타입 배열 / Segment type array /// 0: line, 1: curve pub segment_types: Vec<u8>, } impl ShapeComponentCurve { /// ShapeComponentCurve을 바이트 배열에서 파싱합니다. / Parse ShapeComponentCurve from byte array. /// /// # Arguments /// * `data` - ShapeComponentCurve 데이터 (곡선 개체 속성 부분만) / ShapeComponentCurve data (curve shape component attributes only) /// /// # Returns /// 파싱된 ShapeComponentCurve 구조체 / Parsed ShapeComponentCurve structure /// /// # Note /// 스펙 문서 표 102에 따르면 SHAPE_COMPONENT_CURVE은 다음 구조를 가집니다: /// - 개체 공통 속성(표 68 참조) - 가변 길이 /// - 그리기 개체 공통 속성(표 81 참조) - 가변 길이 /// - 곡선 개체 속성(표 103 참조) - 가변 길이 (2 + 2(4×cnt) + cnt-1 바이트) /// /// 레거시 코드(hwp.js)는 곡선 개체 속성 부분만 파싱하고 있습니다. /// According to spec Table 102, SHAPE_COMPONENT_CURVE has the following structure: /// - Object common properties (Table 68) - variable length /// - Drawing object common properties (Table 81) - variable length /// - Curve shape component attributes (Table 103) - variable length (2 + 2(4×cnt) + cnt-1 bytes) /// /// Legacy code (hwp.js) only parses the curve shape component attributes part. /// /// **테스트 상태 / Testing Status** /// 현재 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_CURVE 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 SHAPE_COMPONENT_CURVE 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain SHAPE_COMPONENT_CURVE records, so it has not been verified with actual files. /// If an actual HWP file contains SHAPE_COMPONENT_CURVE records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // 최소 2바이트 필요 (점의 개수) / Need at least 2 bytes (point count) if data.len() < 2 { return Err(HwpError::insufficient_data("ShapeComponentCurve", 2, data.len())); } let mut offset = 0; // 표 103: 점의 개수 (INT16, 2바이트) / Table 103: Count of points (INT16, 2 bytes) let point_count = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // 점의 개수가 음수이거나 0이면 오류 / If point count is negative or zero, error if point_count <= 0 { return Err(HwpError::UnexpectedValue { field: "ShapeComponentCurve point_count".to_string(), expected: "positive number".to_string(), found: point_count.to_string(), }); } let point_count_usize = point_count as usize; // 필요한 바이트 수 계산 / Calculate required bytes // INT16(2) + INT32 array[cnt](4×cnt) + INT32 array[cnt](4×cnt) + BYTE array[cnt-1](cnt-1) = 2 + 8×cnt + cnt-1 let required_bytes = 2 + 8 * point_count_usize + point_count_usize - 1; if data.len() < required_bytes { return Err(HwpError::InsufficientData { field: format!("ShapeComponentCurve (point_count={})", point_count_usize), expected: required_bytes, actual: data.len(), }); } // 표 103: X 좌표 배열 (INT32 array[cnt], 4×cnt 바이트) / Table 103: X coordinates array (INT32 array[cnt], 4×cnt bytes) let mut x_coordinates = Vec::with_capacity(point_count_usize); for _ in 0..point_count_usize { let x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); x_coordinates.push(x); offset += 4; } // 표 103: Y 좌표 배열 (INT32 array[cnt], 4×cnt 바이트) / Table 103: Y coordinates array (INT32 array[cnt], 4×cnt bytes) let mut y_coordinates = Vec::with_capacity(point_count_usize); for _ in 0..point_count_usize { let y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); y_coordinates.push(y); offset += 4; } // 표 103: 세그먼트 타입 배열 (BYTE array[cnt-1], cnt-1 바이트) / Table 103: Segment type array (BYTE array[cnt-1], cnt-1 bytes) let mut segment_types = Vec::with_capacity(point_count_usize - 1); for _ in 0..(point_count_usize - 1) { segment_types.push(data[offset]); offset += 1; } Ok(ShapeComponentCurve { point_count, x_coordinates, y_coordinates, segment_types, }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/shape_component/polygon.rs

crates/hwp-core/src/document/bodytext/shape_component/polygon.rs

/// ShapeComponentPolygon 구조체 / ShapeComponentPolygon structure /// /// 스펙 문서 매핑: 표 99 - 다각형 개체 속성 / Spec mapping: Table 99 - Polygon shape component attributes /// /// **구현 상태 / Implementation Status** /// - 구현 완료 / Implementation complete /// - 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_POLYGON 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain SHAPE_COMPONENT_POLYGON records use crate::error::HwpError; use crate::types::{INT16, INT32}; use serde::{Deserialize, Serialize}; /// 다각형 개체 / Polygon shape component #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ShapeComponentPolygon { /// 점의 개수 / Count of points pub point_count: INT16, /// X 좌표 배열 / X coordinates array pub x_coordinates: Vec<INT32>, /// Y 좌표 배열 / Y coordinates array pub y_coordinates: Vec<INT32>, } impl ShapeComponentPolygon { /// ShapeComponentPolygon을 바이트 배열에서 파싱합니다. / Parse ShapeComponentPolygon from byte array. /// /// # Arguments /// * `data` - ShapeComponentPolygon 데이터 (다각형 개체 속성 부분만) / ShapeComponentPolygon data (polygon shape component attributes only) /// /// # Returns /// 파싱된 ShapeComponentPolygon 구조체 / Parsed ShapeComponentPolygon structure /// /// # Note /// 스펙 문서 표 98에 따르면 SHAPE_COMPONENT_POLYGON은 다음 구조를 가집니다: /// - 개체 공통 속성(표 68 참조) - 가변 길이 /// - 그리기 개체 공통 속성(표 81 참조) - 가변 길이 /// - 다각형 개체 속성(표 99 참조) - 가변 길이 (2 + 2(4×cnt) 바이트) /// /// 레거시 코드(hwp.js)는 다각형 개체 속성 부분만 파싱하고 있습니다. /// According to spec Table 98, SHAPE_COMPONENT_POLYGON has the following structure: /// - Object common properties (Table 68) - variable length /// - Drawing object common properties (Table 81) - variable length /// - Polygon shape component attributes (Table 99) - variable length (2 + 2(4×cnt) bytes) /// /// Legacy code (hwp.js) only parses the polygon shape component attributes part. /// /// **테스트 상태 / Testing Status** /// 현재 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_POLYGON 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 SHAPE_COMPONENT_POLYGON 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain SHAPE_COMPONENT_POLYGON records, so it has not been verified with actual files. /// If an actual HWP file contains SHAPE_COMPONENT_POLYGON records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // 최소 2바이트 필요 (점의 개수) / Need at least 2 bytes (point count) if data.len() < 2 { return Err(HwpError::insufficient_data("ShapeComponentPolygon", 2, data.len())); } let mut offset = 0; // 표 99: 점의 개수 (INT16, 2바이트) / Table 99: Count of points (INT16, 2 bytes) let point_count = INT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // 점의 개수가 음수이거나 0이면 오류 / If point count is negative or zero, error if point_count <= 0 { return Err(HwpError::UnexpectedValue { field: "ShapeComponentPolygon point_count".to_string(), expected: "positive number".to_string(), found: point_count.to_string(), }); } let point_count_usize = point_count as usize; // 필요한 바이트 수 계산 / Calculate required bytes // INT16(2) + INT32 array[cnt](4×cnt) + INT32 array[cnt](4×cnt) = 2 + 8×cnt let required_bytes = 2 + 8 * point_count_usize; if data.len() < required_bytes { return Err(HwpError::InsufficientData { field: format!("ShapeComponentPolygon (point_count={})", point_count_usize), expected: required_bytes, actual: data.len(), }); } // 표 99: X 좌표 배열 (INT32 array[cnt], 4×cnt 바이트) / Table 99: X coordinates array (INT32 array[cnt], 4×cnt bytes) let mut x_coordinates = Vec::with_capacity(point_count_usize); for _ in 0..point_count_usize { let x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); x_coordinates.push(x); offset += 4; } // 표 99: Y 좌표 배열 (INT32 array[cnt], 4×cnt 바이트) / Table 99: Y coordinates array (INT32 array[cnt], 4×cnt bytes) let mut y_coordinates = Vec::with_capacity(point_count_usize); for _ in 0..point_count_usize { let y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); y_coordinates.push(y); offset += 4; } Ok(ShapeComponentPolygon { point_count, x_coordinates, y_coordinates, }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/shape_component/mod.rs

crates/hwp-core/src/document/bodytext/shape_component/mod.rs

mod common; mod arc; mod container; mod curve; mod ellipse; mod line; mod ole; mod picture; mod polygon; mod rectangle; mod textart; mod unknown; pub use common::ShapeComponent; pub use arc::ShapeComponentArc; pub use container::ShapeComponentContainer; pub use curve::ShapeComponentCurve; pub use ellipse::ShapeComponentEllipse; pub use line::ShapeComponentLine; pub use ole::ShapeComponentOle; pub use picture::ShapeComponentPicture; pub use polygon::ShapeComponentPolygon; pub use rectangle::ShapeComponentRectangle; pub use textart::ShapeComponentTextArt; pub use unknown::ShapeComponentUnknown;

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/shape_component/common.rs

crates/hwp-core/src/document/bodytext/shape_component/common.rs

/// ShapeComponent 구조체 / ShapeComponent structure /// /// 스펙 문서 매핑: 표 82, 83 - 개체 요소 속성 / Spec mapping: Table 82, 83 - Shape component attributes use crate::error::HwpError; use crate::types::{HWPUNIT16, INT32, UINT16, UINT32}; use serde::{Deserialize, Serialize}; /// 개체 요소 / Shape component #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ShapeComponent { /// 개체 컨트롤 ID / Object control ID pub object_control_id: String, /// 개체 컨트롤 ID 2 (GenShapeObject일 경우 id가 두 번 기록됨) / Object control ID 2 (for GenShapeObject, ID is recorded twice) #[serde(skip_serializing_if = "Option::is_none")] pub object_control_id2: Option<String>, /// 개체가 속한 그룹 내에서의 offset / Offset within group pub group_offset: GroupOffset, /// 몇 번이나 그룹 되었는지 / Number of times grouped pub group_count: UINT16, /// 개체 요소의 local file version / Local file version pub local_version: UINT16, /// 개체 생성 시 초기 폭 / Initial width pub initial_width: UINT32, /// 개체 생성 시 초기 높이 / Initial height pub initial_height: UINT32, /// 개체의 현재 폭 / Current width pub width: UINT32, /// 개체의 현재 높이 / Current height pub height: UINT32, /// 속성 / Attributes pub attributes: ShapeComponentAttributes, /// 회전각 / Rotation angle pub rotation_angle: HWPUNIT16, /// 회전 중심 좌표 / Rotation center coordinates pub rotation_center: RotationCenter, /// Rendering 정보 / Rendering information pub rendering: RenderingInfo, } /// 개체가 속한 그룹 내에서의 offset / Offset within group #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct GroupOffset { /// X offset pub x: INT32, /// Y offset pub y: INT32, } /// 개체 요소 속성 / Shape component attributes #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum ShapeComponentAttributes { /// 수평 뒤집기 / Horizontal flip HorizontalFlip, /// 수직 뒤집기 / Vertical flip VerticalFlip, } /// 회전 중심 좌표 / Rotation center coordinates #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct RotationCenter { /// X 좌표(개체 좌표계) / X coordinate (object coordinate system) pub x: INT32, /// Y 좌표(개체 좌표계) / Y coordinate (object coordinate system) pub y: INT32, } /// Rendering 정보 / Rendering information #[derive(Debug, Clone, Serialize, Deserialize)] pub struct RenderingInfo { /// scale matrix와 rotation matrix쌍의 개수 / Number of scale matrix and rotation matrix pairs pub matrix_count: UINT16, /// translation matrix / Translation matrix pub translation_matrix: Matrix, /// scale matrix/rotation matrix sequence / Scale matrix/rotation matrix sequence pub matrix_sequence: Vec<MatrixPair>, } /// Matrix 정보 / Matrix information /// 3X3 matrix의 원소 (마지막 줄은 항상 0, 0, 1이므로 저장되지 않음) /// Elements of 3X3 matrix (last row is always 0, 0, 1 so not stored) #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct Matrix { /// 3X2 matrix의 원소 (6개 double 값, 48바이트) / Elements of 3X2 matrix (6 double values, 48 bytes) pub elements: [f64; 6], } /// Matrix 쌍 / Matrix pair #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct MatrixPair { /// Scale matrix pub scale: Matrix, /// Rotation matrix pub rotation: Matrix, } impl ShapeComponent { /// ShapeComponent를 바이트 배열에서 파싱합니다. / Parse ShapeComponent from byte array. /// /// # Arguments /// * `data` - ShapeComponent 데이터 / ShapeComponent data /// /// # Returns /// 파싱된 ShapeComponent 구조체 / Parsed ShapeComponent structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 4 { return Err(HwpError::insufficient_data("ShapeComponent", 4, data.len())); } let mut offset = 0; // 표 82: 개체 컨트롤 ID (UINT32, 4바이트) / Table 82: Object control ID (UINT32, 4 bytes) let ctrl_id_value1 = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // ctrl_id를 문자열로 변환 (4바이트 ASCII) / Convert ctrl_id to string (4-byte ASCII) let object_control_id = String::from_utf8_lossy(&data[offset - 4..offset]) .trim_end_matches('\0') .trim_end_matches(' ') .to_string(); // 스펙 문서 표 82 주석: "GenShapeObject일 경우 id가 두 번 기록됨" // 하지만 실제 파일에서는 모든 SHAPE_COMPONENT에서 두 번째 ID가 존재함 // 레거시 코드도 항상 두 번째 ID를 읽고 있음 // Spec Table 82 comment: "For GenShapeObject, ID is recorded twice" // However, in actual files, second ID exists in all SHAPE_COMPONENT records // Legacy code also always reads the second ID let object_control_id2 = if data.len() >= offset + 4 { // 두 번째 ID 읽기 / Read second ID let ctrl_id_value2 = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; Some( String::from_utf8_lossy(&data[offset - 4..offset]) .trim_end_matches('\0') .trim_end_matches(' ') .to_string(), ) } else { None }; // 표 83: 개체 요소 속성 / Table 83: Shape component attributes if data.len() < offset + 42 { return Err(HwpError::InsufficientData { field: format!("ShapeComponent attributes at offset {}", offset), expected: offset + 42, actual: data.len(), }); } // INT32: 개체가 속한 그룹 내에서의 X offset / INT32: X offset within group let group_x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // INT32: 개체가 속한 그룹 내에서의 Y offset / INT32: Y offset within group let group_y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // WORD: 몇 번이나 그룹 되었는지 / WORD: Number of times grouped let group_count = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // WORD: 개체 요소의 local file version / WORD: Local file version let local_version = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // UINT32: 개체 생성 시 초기 폭 / UINT32: Initial width let initial_width = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // UINT32: 개체 생성 시 초기 높이 / UINT32: Initial height let initial_height = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // UINT32: 개체의 현재 폭 / UINT32: Current width let width = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // UINT32: 개체의 현재 높이 / UINT32: Current height let height = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // UINT32: 속성 / UINT32: Attributes // 0: horz flip, 1: vert flip let attribute_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let attributes = if attribute_value == 0 { ShapeComponentAttributes::HorizontalFlip } else { ShapeComponentAttributes::VerticalFlip }; // HWPUNIT16: 회전각 / HWPUNIT16: Rotation angle let rotation_angle = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // INT32: 회전 중심의 x 좌표(개체 좌표계) / INT32: Rotation center x coordinate (object coordinate system) let rotation_center_x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // INT32: 회전 중심의 y 좌표(개체 좌표계) / INT32: Rotation center y coordinate (object coordinate system) let rotation_center_y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 84: Rendering 정보 / Table 84: Rendering information if data.len() < offset + 2 { return Err(HwpError::insufficient_data( "ShapeComponent rendering info", 2, data.len() - offset, )); } // WORD: scale matrix와 rotation matrix쌍의 개수 / WORD: Number of scale matrix and rotation matrix pairs let matrix_count = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; // BYTE stream (48바이트): translation matrix / BYTE stream (48 bytes): Translation matrix if data.len() < offset + 48 { return Err(HwpError::InsufficientData { field: format!("ShapeComponent translation matrix at offset {}", offset), expected: offset + 48, actual: data.len(), }); } let translation_matrix = parse_matrix(&data[offset..offset + 48]).map_err(|e| HwpError::from(e))?; offset += 48; // BYTE stream (cnt×48×2): scale matrix/rotation matrix sequence let matrix_sequence_size = matrix_count as usize * 48 * 2; if data.len() < offset + matrix_sequence_size { return Err(HwpError::InsufficientData { field: format!("ShapeComponent matrix sequence at offset {}", offset), expected: offset + matrix_sequence_size, actual: data.len(), }); } let mut matrix_sequence = Vec::new(); for i in 0..matrix_count as usize { let seq_offset = offset + (i * 48 * 2); let scale_matrix = parse_matrix(&data[seq_offset..seq_offset + 48]).map_err(|e| HwpError::from(e))?; let rotation_matrix = parse_matrix(&data[seq_offset + 48..seq_offset + 96]) .map_err(|e| HwpError::from(e))?; matrix_sequence.push(MatrixPair { scale: scale_matrix, rotation: rotation_matrix, }); } let _ = offset + matrix_sequence_size; // offset은 더 이상 사용되지 않음 / offset is no longer used Ok(ShapeComponent { object_control_id, object_control_id2, group_offset: GroupOffset { x: group_x, y: group_y, }, group_count, local_version, initial_width, initial_height, width, height, attributes, rotation_angle, rotation_center: RotationCenter { x: rotation_center_x, y: rotation_center_y, }, rendering: RenderingInfo { matrix_count, translation_matrix, matrix_sequence, }, }) } } /// Matrix 파싱 (표 85) / Parse matrix (Table 85) /// double array[6] (48바이트) - 3X2 matrix의 원소 / double array[6] (48 bytes) - Elements of 3X2 matrix fn parse_matrix(data: &[u8]) -> Result<Matrix, HwpError> { if data.len() < 48 { return Err(HwpError::insufficient_data("Matrix", 48, data.len())); } let mut elements = [0.0; 6]; for (i, element) in elements.iter_mut().enumerate() { let offset = i * 8; *element = f64::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], data[offset + 4], data[offset + 5], data[offset + 6], data[offset + 7], ]); } Ok(Matrix { elements }) }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/shape_component/line.rs

crates/hwp-core/src/document/bodytext/shape_component/line.rs

/// ShapeComponentLine 구조체 / ShapeComponentLine structure /// /// 스펙 문서 매핑: 표 92 - 선 개체 속성 / Spec mapping: Table 92 - Line shape component attributes /// /// **구현 상태 / Implementation Status** /// - 구현 완료 / Implementation complete /// - 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_LINE 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain SHAPE_COMPONENT_LINE records use crate::error::HwpError; use crate::types::{INT32, UINT16}; use serde::{Deserialize, Serialize}; /// 선 개체 / Line shape component #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ShapeComponentLine { /// 시작점 / Start point pub start_point: Point, /// 끝점 / End point pub end_point: Point, /// 속성 / Attributes /// 처음 생성 시 수직 또는 수평선일 때, 선의 방향이 언제나 오른쪽(위쪽)으로 잡힘으로 인한 현상 때문에, 방향을 바로 잡아주기 위한 플래그 /// Flag to correct direction when initially created as vertical or horizontal line, /// as the direction is always set to right (up) due to a phenomenon pub flag: UINT16, } /// 점 좌표 / Point coordinates #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct Point { /// X 좌표 / X coordinate pub x: INT32, /// Y 좌표 / Y coordinate pub y: INT32, } impl ShapeComponentLine { /// ShapeComponentLine을 바이트 배열에서 파싱합니다. / Parse ShapeComponentLine from byte array. /// /// # Arguments /// * `data` - ShapeComponentLine 데이터 (선 개체 속성 부분만) / ShapeComponentLine data (line shape component attributes only) /// /// # Returns /// 파싱된 ShapeComponentLine 구조체 / Parsed ShapeComponentLine structure /// /// # Note /// 스펙 문서 표 91에 따르면 SHAPE_COMPONENT_LINE은 다음 구조를 가집니다: /// - 개체 공통 속성(표 68 참조) - 가변 길이 /// - 그리기 개체 공통 속성(표 81 참조) - 가변 길이 /// - 선 개체 속성(표 92 참조) - 18바이트 /// /// 레거시 코드(hwp.js)는 선 개체 속성 부분만 파싱하고 있습니다. /// According to spec Table 91, SHAPE_COMPONENT_LINE has the following structure: /// - Object common properties (Table 68) - variable length /// - Drawing object common properties (Table 81) - variable length /// - Line shape component attributes (Table 92) - 18 bytes /// /// Legacy code (hwp.js) only parses the line shape component attributes part. /// /// **테스트 상태 / Testing Status** /// 현재 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_LINE 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 SHAPE_COMPONENT_LINE 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain SHAPE_COMPONENT_LINE records, so it has not been verified with actual files. /// If an actual HWP file contains SHAPE_COMPONENT_LINE records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // 표 92: 선 개체 속성은 18바이트 / Table 92: Line shape component attributes is 18 bytes // INT32(4) + INT32(4) + INT32(4) + INT32(4) + UINT16(2) = 18 bytes if data.len() < 18 { return Err(HwpError::insufficient_data("ShapeComponentLine", 18, data.len())); } let mut offset = 0; // 표 92: 시작점 X 좌표 (INT32, 4바이트) / Table 92: Start point X coordinate (INT32, 4 bytes) let start_x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 92: 시작점 Y 좌표 (INT32, 4바이트) / Table 92: Start point Y coordinate (INT32, 4 bytes) let start_y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 92: 끝점 X 좌표 (INT32, 4바이트) / Table 92: End point X coordinate (INT32, 4 bytes) let end_x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 92: 끝점 Y 좌표 (INT32, 4바이트) / Table 92: End point Y coordinate (INT32, 4 bytes) let end_y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 92: 속성 (UINT16, 2바이트) / Table 92: Attributes (UINT16, 2 bytes) let flag = UINT16::from_le_bytes([data[offset], data[offset + 1]]); Ok(ShapeComponentLine { start_point: Point { x: start_x, y: start_y, }, end_point: Point { x: end_x, y: end_y }, flag, }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/shape_component/ellipse.rs

crates/hwp-core/src/document/bodytext/shape_component/ellipse.rs

/// ShapeComponentEllipse 구조체 / ShapeComponentEllipse structure /// /// 스펙 문서 매핑: 표 96 - 타원 개체 속성 / Spec mapping: Table 96 - Ellipse shape component attributes /// /// **구현 상태 / Implementation Status** /// - 구현 완료 / Implementation complete /// - 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_ELLIPSE 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain SHAPE_COMPONENT_ELLIPSE records use crate::error::HwpError; use crate::types::{INT32, UINT32}; use serde::{Deserialize, Serialize}; /// 타원 개체 / Ellipse shape component #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ShapeComponentEllipse { /// 속성 / Attributes (표 97 참조 / See Table 97) pub attributes: EllipseArcAttributes, /// 중심 좌표 / Center coordinates pub center: Point, /// 제1축 좌표 / First axis coordinates pub axis1: Point, /// 제2축 좌표 / Second axis coordinates pub axis2: Point, /// 시작 위치 / Start position pub start_pos: Point, /// 끝 위치 / End position pub end_pos: Point, /// 시작 위치 2 / Start position 2 pub start_pos2: Point, /// 곡선 간격 (호일 때만 유효) / Interval of curve (effective only when it is an arc) pub interval: INT32, /// 끝 위치 2 / End position 2 pub end_pos2: Point, } /// 타원/호 개체 속성 / Ellipse/Arc shape component attributes #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct EllipseArcAttributes { /// 호(ARC)로 바뀌었을 때, interval을 다시 계산해야 할 필요가 있는지 여부 / Whether interval needs to be recalculated when changed to ARC /// (interval - 원 위에 존재하는 두 점 사이의 거리) / (interval - distance between two points on the circle) pub needs_interval_recalculation: bool, /// 호(ARC)로 바뀌었는지 여부 / Whether it has been changed to ARC pub is_arc: bool, /// 호(ARC)의 종류 / ARC type pub arc_type: u8, } /// 점 좌표 / Point coordinates #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct Point { /// X 좌표 / X coordinate pub x: INT32, /// Y 좌표 / Y coordinate pub y: INT32, } impl ShapeComponentEllipse { /// ShapeComponentEllipse을 바이트 배열에서 파싱합니다. / Parse ShapeComponentEllipse from byte array. /// /// # Arguments /// * `data` - ShapeComponentEllipse 데이터 (타원 개체 속성 부분만) / ShapeComponentEllipse data (ellipse shape component attributes only) /// /// # Returns /// 파싱된 ShapeComponentEllipse 구조체 / Parsed ShapeComponentEllipse structure /// /// # Note /// 스펙 문서 표 95에 따르면 SHAPE_COMPONENT_ELLIPSE은 다음 구조를 가집니다: /// - 개체 공통 속성(표 68 참조) - 가변 길이 /// - 그리기 개체 공통 속성(표 81 참조) - 가변 길이 /// - 타원 개체 속성(표 96 참조) - 60바이트 /// /// 레거시 코드(hwp.js)는 타원 개체 속성 부분만 파싱하고 있습니다. /// According to spec Table 95, SHAPE_COMPONENT_ELLIPSE has the following structure: /// - Object common properties (Table 68) - variable length /// - Drawing object common properties (Table 81) - variable length /// - Ellipse shape component attributes (Table 96) - 60 bytes /// /// Legacy code (hwp.js) only parses the ellipse shape component attributes part. /// /// **테스트 상태 / Testing Status** /// 현재 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_ELLIPSE 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 SHAPE_COMPONENT_ELLIPSE 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain SHAPE_COMPONENT_ELLIPSE records, so it has not been verified with actual files. /// If an actual HWP file contains SHAPE_COMPONENT_ELLIPSE records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // 표 96: 타원 개체 속성은 60바이트 / Table 96: Ellipse shape component attributes is 60 bytes // UINT32(4) + INT32(4) * 14 = 60 bytes if data.len() < 60 { return Err(HwpError::insufficient_data("ShapeComponentEllipse", 60, data.len())); } let mut offset = 0; // 표 96: 속성 (UINT32, 4바이트) / Table 96: Attributes (UINT32, 4 bytes) let attr_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 97: 속성 비트 필드 파싱 / Table 97: Parse attribute bit fields let needs_interval_recalculation = (attr_value & 0x01) != 0; // bit 0 let is_arc = (attr_value & 0x02) != 0; // bit 1 let arc_type = ((attr_value >> 2) & 0xFF) as u8; // bit 2-9 // 표 96: 중심 좌표의 X 값 (INT32, 4바이트) / Table 96: Center X coordinate (INT32, 4 bytes) let center_x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 96: 중심 좌표의 Y 값 (INT32, 4바이트) / Table 96: Center Y coordinate (INT32, 4 bytes) let center_y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 96: 제1축 X 좌표 값 (INT32, 4바이트) / Table 96: First axis X coordinate (INT32, 4 bytes) let axis1_x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 96: 제1축 Y 좌표 값 (INT32, 4바이트) / Table 96: First axis Y coordinate (INT32, 4 bytes) let axis1_y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 96: 제2축 X 좌표 값 (INT32, 4바이트) / Table 96: Second axis X coordinate (INT32, 4 bytes) let axis2_x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 96: 제2축 Y 좌표 값 (INT32, 4바이트) / Table 96: Second axis Y coordinate (INT32, 4 bytes) let axis2_y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 96: start pos x (INT32, 4바이트) / Table 96: Start position X (INT32, 4 bytes) let start_pos_x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 96: start pos y (INT32, 4바이트) / Table 96: Start position Y (INT32, 4 bytes) let start_pos_y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 96: end pos x (INT32, 4바이트) / Table 96: End position X (INT32, 4 bytes) let end_pos_x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 96: end pos y (INT32, 4바이트) / Table 96: End position Y (INT32, 4 bytes) let end_pos_y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 96: start pos x2 (INT32, 4바이트) / Table 96: Start position X2 (INT32, 4 bytes) let start_pos2_x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 96: interval of curve (INT32, 4바이트) / Table 96: Interval of curve (INT32, 4 bytes) let interval = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 96: start pos y2 (INT32, 4바이트) / Table 96: Start position Y2 (INT32, 4 bytes) let start_pos2_y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 96: end pos x2 (INT32, 4바이트) / Table 96: End position X2 (INT32, 4 bytes) let end_pos_x2 = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 96: end pos y2 (INT32, 4바이트) / Table 96: End position Y2 (INT32, 4 bytes) let end_pos_y2 = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); Ok(ShapeComponentEllipse { attributes: EllipseArcAttributes { needs_interval_recalculation, is_arc, arc_type, }, center: Point { x: center_x, y: center_y, }, axis1: Point { x: axis1_x, y: axis1_y, }, axis2: Point { x: axis2_x, y: axis2_y, }, start_pos: Point { x: start_pos_x, y: start_pos_y, }, end_pos: Point { x: end_pos_x, y: end_pos_y, }, start_pos2: Point { x: start_pos2_x, y: start_pos2_y, }, interval, end_pos2: Point { x: end_pos_x2, y: end_pos_y2, }, }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/shape_component/arc.rs

crates/hwp-core/src/document/bodytext/shape_component/arc.rs

/// ShapeComponentArc 구조체 / ShapeComponentArc structure /// /// 스펙 문서 매핑: 표 101 - 호 개체 속성 / Spec mapping: Table 101 - Arc shape component attributes /// /// **구현 상태 / Implementation Status** /// - 구현 완료 / Implementation complete /// - 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_ARC 레코드가 없어 실제 파일로 테스트되지 않음 /// - Implementation complete, but not tested with actual file as test file (`noori.hwp`) does not contain SHAPE_COMPONENT_ARC records use crate::error::HwpError; use crate::types::{INT32, UINT32}; use serde::{Deserialize, Serialize}; /// 호 개체 / Arc shape component #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ShapeComponentArc { /// 속성 / Attributes (표 97 참조 / See Table 97) pub attributes: EllipseArcAttributes, /// 타원의 중심 좌표 / Ellipse center coordinates pub ellipse_center: Point, /// 제1축 좌표 / First axis coordinates pub axis1: Point, /// 제2축 좌표 / Second axis coordinates pub axis2: Point, } /// 타원/호 개체 속성 / Ellipse/Arc shape component attributes #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct EllipseArcAttributes { /// 호(ARC)로 바뀌었을 때, interval을 다시 계산해야 할 필요가 있는지 여부 / Whether interval needs to be recalculated when changed to ARC /// (interval - 원 위에 존재하는 두 점 사이의 거리) / (interval - distance between two points on the circle) pub needs_interval_recalculation: bool, /// 호(ARC)로 바뀌었는지 여부 / Whether it has been changed to ARC pub is_arc: bool, /// 호(ARC)의 종류 / ARC type pub arc_type: u8, } /// 점 좌표 / Point coordinates #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct Point { /// X 좌표 / X coordinate pub x: INT32, /// Y 좌표 / Y coordinate pub y: INT32, } impl ShapeComponentArc { /// ShapeComponentArc을 바이트 배열에서 파싱합니다. / Parse ShapeComponentArc from byte array. /// /// # Arguments /// * `data` - ShapeComponentArc 데이터 (호 개체 속성 부분만) / ShapeComponentArc data (arc shape component attributes only) /// /// # Returns /// 파싱된 ShapeComponentArc 구조체 / Parsed ShapeComponentArc structure /// /// # Note /// 스펙 문서 표 100에 따르면 SHAPE_COMPONENT_ARC은 다음 구조를 가집니다: /// - 개체 공통 속성(표 68 참조) - 가변 길이 /// - 그리기 개체 공통 속성(표 81 참조) - 가변 길이 /// - 호 개체 속성(표 101 참조) - 28바이트 /// /// 레거시 코드(hwp.js)는 호 개체 속성 부분만 파싱하고 있습니다. /// According to spec Table 100, SHAPE_COMPONENT_ARC has the following structure: /// - Object common properties (Table 68) - variable length /// - Drawing object common properties (Table 81) - variable length /// - Arc shape component attributes (Table 101) - 28 bytes /// /// Legacy code (hwp.js) only parses the arc shape component attributes part. /// /// **테스트 상태 / Testing Status** /// 현재 테스트 파일(`noori.hwp`)에 SHAPE_COMPONENT_ARC 레코드가 없어 실제 파일로 검증되지 않았습니다. /// 실제 HWP 파일에 SHAPE_COMPONENT_ARC 레코드가 있으면 자동으로 파싱됩니다. /// Current test file (`noori.hwp`) does not contain SHAPE_COMPONENT_ARC records, so it has not been verified with actual files. /// If an actual HWP file contains SHAPE_COMPONENT_ARC records, they will be automatically parsed. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { // 표 101: 호 개체 속성은 28바이트 / Table 101: Arc shape component attributes is 28 bytes // UINT32(4) + INT32(4) * 6 = 28 bytes if data.len() < 28 { return Err(HwpError::insufficient_data("ShapeComponentArc", 28, data.len())); } let mut offset = 0; // 표 101: 속성 (UINT32, 4바이트) / Table 101: Attributes (UINT32, 4 bytes) let attr_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 97: 속성 비트 필드 파싱 / Table 97: Parse attribute bit fields let needs_interval_recalculation = (attr_value & 0x01) != 0; // bit 0 let is_arc = (attr_value & 0x02) != 0; // bit 1 let arc_type = ((attr_value >> 2) & 0xFF) as u8; // bit 2-9 // 표 101: 타원의 중심 좌표 X 값 (INT32, 4바이트) / Table 101: Ellipse center X coordinate (INT32, 4 bytes) let center_x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 101: 타원의 중심 좌표 Y 값 (INT32, 4바이트) / Table 101: Ellipse center Y coordinate (INT32, 4 bytes) let center_y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 101: 제1축 X 좌표 값 (INT32, 4바이트) / Table 101: First axis X coordinate (INT32, 4 bytes) let axis1_x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 101: 제1축 Y 좌표 값 (INT32, 4바이트) / Table 101: First axis Y coordinate (INT32, 4 bytes) let axis1_y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 101: 제2축 X 좌표 값 (INT32, 4바이트) / Table 101: Second axis X coordinate (INT32, 4 bytes) let axis2_x = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; // 표 101: 제2축 Y 좌표 값 (INT32, 4바이트) / Table 101: Second axis Y coordinate (INT32, 4 bytes) let axis2_y = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); Ok(ShapeComponentArc { attributes: EllipseArcAttributes { needs_interval_recalculation, is_arc, arc_type, }, ellipse_center: Point { x: center_x, y: center_y, }, axis1: Point { x: axis1_x, y: axis1_y, }, axis2: Point { x: axis2_x, y: axis2_y, }, }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/field.rs

crates/hwp-core/src/document/bodytext/ctrl_header/field.rs

use crate::error::HwpError; use crate::types::decode_utf16le; use crate::types::{UINT16, UINT32, UINT8}; use super::types::CtrlHeaderData; /// 필드 파싱 (표 152) / Parse field (Table 152) pub(crate) fn parse_field(data: &[u8]) -> Result<CtrlHeaderData, HwpError> { if data.len() < 15 { return Err(HwpError::insufficient_data("Field data", 15, data.len())); } let mut offset = 0usize; let field_type_bytes = [ data[offset + 3], data[offset + 2], data[offset + 1], data[offset], ]; let field_type = String::from_utf8_lossy(&field_type_bytes) .trim_end_matches('\0') .to_string(); offset += 4; let attribute = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let other_attr = UINT8::from_le_bytes([data[offset]]); offset += 1; let command_len = UINT16::from_le_bytes([data[offset], data[offset + 1]]) as usize; offset += 2; let command = if command_len > 0 && offset + (command_len * 2) <= data.len() { let command_bytes = &data[offset..offset + (command_len * 2)]; decode_utf16le(command_bytes).unwrap_or_default() } else { String::new() }; offset += command_len * 2; let id = if offset + 4 <= data.len() { UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]) } else { 0 }; Ok(CtrlHeaderData::Field { field_type, attribute, other_attr, command_len: command_len as UINT16, command, id, }) }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/object_common.rs

crates/hwp-core/src/document/bodytext/ctrl_header/object_common.rs

use crate::error::HwpError; use crate::types::decode_utf16le; use crate::types::{HWPUNIT, HWPUNIT16, INT32, SHWPUNIT, UINT16, UINT32}; use super::types::{ CtrlHeaderData, HorzRelTo, Margin, ObjectAttribute, ObjectCategory, ObjectHeightStandard, ObjectTextOption, ObjectTextPositionOption, ObjectWidthStandard, VertRelTo, }; /// 개체 공통 속성 파싱 (표 69) / Parse object common properties (Table 69) pub(crate) fn parse_object_common(data: &[u8]) -> Result<CtrlHeaderData, HwpError> { if data.len() < 40 { return Err(HwpError::insufficient_data( "Object common properties", 40, data.len(), )); } let mut offset = 0usize; let attribute_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let offset_y = SHWPUNIT::from(INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; let offset_x = SHWPUNIT::from(INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; let width = HWPUNIT::from(UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; let height = HWPUNIT::from(UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])); offset += 4; let z_order = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let margin_bottom = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let margin_left = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let margin_right = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let margin_top = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let instance_id = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let page_divide = INT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let description = if offset + 2 <= data.len() { let description_len = UINT16::from_le_bytes([data[offset], data[offset + 1]]) as usize; offset += 2; if description_len > 0 && offset + (description_len * 2) <= data.len() { let description_bytes = &data[offset..offset + (description_len * 2)]; match decode_utf16le(description_bytes) { Ok(text) if !text.is_empty() => Some(text), _ => None, } } else { None } } else { None }; let attribute = parse_object_attribute(attribute_value); Ok(CtrlHeaderData::ObjectCommon { attribute, offset_y, offset_x, width, height, z_order, margin: Margin { top: margin_top, right: margin_right, bottom: margin_bottom, left: margin_left, }, instance_id, page_divide, description, caption: None, }) } /// 개체 속성 파싱 (표 70) / Parse object attribute (Table 70) fn parse_object_attribute(value: UINT32) -> ObjectAttribute { let like_letters = (value & 0x01) != 0; let affect_line_spacing = (value & 0x04) != 0; let vert_rel_to = match (value >> 3) & 0x03 { 0 => VertRelTo::Paper, 1 => VertRelTo::Page, 2 => VertRelTo::Para, _ => VertRelTo::Para, }; let vert_relative = ((value >> 5) & 0x07) as u8; // NOTE (HWP spec Table 70): // vert_rel_to has Paper/Page/Para; horz_rel_to also has Paper/Page/Column/Para. // Previously we collapsed (0|1) into Page which loses "paper" anchors and breaks fixtures // (e.g. table-position '표 5' should be paper-left 35mm, but became page-left 65mm). let horz_rel_to = match (value >> 8) & 0x03 { 0 => HorzRelTo::Paper, 1 => HorzRelTo::Page, 2 => HorzRelTo::Column, 3 => HorzRelTo::Para, _ => HorzRelTo::Page, }; let horz_relative = ((value >> 10) & 0x07) as u8; let vert_rel_to_para_limit = (value & 0x2000) != 0; let overlap = (value & 0x4000) != 0; let object_width_standard = match (value >> 15) & 0x07 { 0 => ObjectWidthStandard::Paper, 1 => ObjectWidthStandard::Page, 2 => ObjectWidthStandard::Column, 3 => ObjectWidthStandard::Para, 4 => ObjectWidthStandard::Absolute, _ => ObjectWidthStandard::Absolute, }; let object_height_standard = match (value >> 18) & 0x03 { 0 => ObjectHeightStandard::Paper, 1 => ObjectHeightStandard::Page, 2 => ObjectHeightStandard::Absolute, _ => ObjectHeightStandard::Absolute, }; let object_text_option = match (value >> 21) & 0x07 { 0 => ObjectTextOption::Square, 1 => ObjectTextOption::Tight, 2 => ObjectTextOption::Through, 3 => ObjectTextOption::TopAndBottom, 4 => ObjectTextOption::BehindText, 5 => ObjectTextOption::InFrontOfText, _ => ObjectTextOption::Square, }; let object_text_position_option = match (value >> 24) & 0x03 { 0 => ObjectTextPositionOption::BothSides, 1 => ObjectTextPositionOption::LeftOnly, 2 => ObjectTextPositionOption::RightOnly, 3 => ObjectTextPositionOption::LargestOnly, _ => ObjectTextPositionOption::BothSides, }; let object_category = match (value >> 26) & 0x07 { 0 => ObjectCategory::None, 1 => ObjectCategory::Figure, 2 => ObjectCategory::Table, 3 => ObjectCategory::Equation, _ => ObjectCategory::None, }; let size_protect = (value & 0x100000) != 0; ObjectAttribute { like_letters, affect_line_spacing, vert_rel_to, vert_relative, horz_rel_to, horz_relative, vert_rel_to_para_limit, overlap, object_width_standard, object_height_standard, object_text_option, object_text_position_option, object_category, size_protect, } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/bookmark_marker.rs

crates/hwp-core/src/document/bodytext/ctrl_header/bookmark_marker.rs

use crate::error::HwpError; use crate::types::decode_utf16le; use crate::types::UINT16; use super::types::CtrlHeaderData; /// 찾아보기 표식 파싱 (표 149) / Parse bookmark marker (Table 149) pub(crate) fn parse_bookmark_marker(data: &[u8]) -> Result<CtrlHeaderData, HwpError> { if data.len() < 6 { return Err(HwpError::insufficient_data("Bookmark marker", 6, data.len())); } let mut offset = 0usize; let keyword1_len = UINT16::from_le_bytes([data[offset], data[offset + 1]]) as usize; offset += 2; let keyword1 = if keyword1_len > 0 && offset + (keyword1_len * 2) <= data.len() { let keyword1_bytes = &data[offset..offset + (keyword1_len * 2)]; decode_utf16le(keyword1_bytes).unwrap_or_default() } else { String::new() }; offset += keyword1_len * 2; let keyword2_len = if offset + 2 <= data.len() { UINT16::from_le_bytes([data[offset], data[offset + 1]]) as usize } else { 0 }; offset += 2; let keyword2 = if keyword2_len > 0 && offset + (keyword2_len * 2) <= data.len() { let keyword2_bytes = &data[offset..offset + (keyword2_len * 2)]; decode_utf16le(keyword2_bytes).unwrap_or_default() } else { String::new() }; Ok(CtrlHeaderData::BookmarkMarker { keyword1, keyword2 }) }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/page_number_position.rs

crates/hwp-core/src/document/bodytext/ctrl_header/page_number_position.rs

use crate::error::HwpError; use crate::types::decode_utf16le; use crate::types::UINT32; use super::types::{CtrlHeaderData, PageNumberPosition, PageNumberPositionFlags}; /// 쪽 번호 위치 파싱 (표 147) / Parse page number position (Table 147) pub(crate) fn parse_page_number_position(data: &[u8]) -> Result<CtrlHeaderData, HwpError> { if data.len() < 12 { return Err(HwpError::insufficient_data( "PageNumberPosition", 12, data.len(), )); } let mut offset = 0usize; let flags_value = UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let shape = (flags_value & 0xFF) as u8; let position = match (flags_value >> 8) & 0x0F { 0 => PageNumberPosition::None, 1 => PageNumberPosition::TopLeft, 2 => PageNumberPosition::TopCenter, 3 => PageNumberPosition::TopRight, 4 => PageNumberPosition::BottomLeft, 5 => PageNumberPosition::BottomCenter, 6 => PageNumberPosition::BottomRight, 7 => PageNumberPosition::OutsideTop, 8 => PageNumberPosition::OutsideBottom, 9 => PageNumberPosition::InsideTop, 10 => PageNumberPosition::InsideBottom, _ => PageNumberPosition::None, }; let flags = PageNumberPositionFlags { shape, position }; let user_symbol = decode_utf16le(&data[offset..offset + 2])?; offset += 2; let prefix = decode_utf16le(&data[offset..offset + 2])?; offset += 2; let suffix = decode_utf16le(&data[offset..offset + 2])?; Ok(CtrlHeaderData::PageNumberPosition { flags, user_symbol, prefix, suffix, }) }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/footnote_endnote.rs

crates/hwp-core/src/document/bodytext/ctrl_header/footnote_endnote.rs

use crate::error::HwpError; use super::types::CtrlHeaderData; /// 각주/미주 파싱 (표 4.3.10.4) / Parse footnote/endnote (Table 4.3.10.4) pub(crate) fn parse_footnote_endnote(data: &[u8]) -> Result<CtrlHeaderData, HwpError> { if data.len() < 8 { return Err(HwpError::insufficient_data( "Footnote/endnote", 8, data.len(), )); } let number = data[0]; let mut reserved = [0u8; 5]; reserved.copy_from_slice(&data[1..6]); let attribute = data[6]; let reserved2 = data[7]; Ok(CtrlHeaderData::FootnoteEndnote { number, reserved, attribute, reserved2, }) }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/hide.rs

crates/hwp-core/src/document/bodytext/ctrl_header/hide.rs

use crate::error::HwpError; use crate::types::UINT16; use super::types::CtrlHeaderData; /// 감추기 파싱 (표 145) / Parse hide (Table 145) pub(crate) fn parse_hide(data: &[u8]) -> Result<CtrlHeaderData, HwpError> { if data.len() < 2 { return Err(HwpError::insufficient_data("Hide", 2, data.len())); } let attribute = UINT16::from_le_bytes([data[0], data[1]]); Ok(CtrlHeaderData::Hide { attribute }) }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/header_footer.rs

crates/hwp-core/src/document/bodytext/ctrl_header/header_footer.rs

use crate::error::HwpError; use crate::types::{HWPUNIT, UINT32}; use super::types::{ApplyPage, CtrlHeaderData, HeaderFooterAttribute}; /// 머리말/꼬리말 파싱 (표 140) / Parse header/footer (Table 140) pub(crate) fn parse_header_footer(data: &[u8]) -> Result<CtrlHeaderData, HwpError> { if data.len() < 4 { return Err(HwpError::insufficient_data("Header/Footer", 4, data.len())); } let mut offset = 0usize; let attribute_value = UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]); offset += 4; let apply_page = match attribute_value & 0x03 { 0 => ApplyPage::Both, 1 => ApplyPage::EvenOnly, 2 => ApplyPage::OddOnly, _ => ApplyPage::Both, }; let attribute = HeaderFooterAttribute { apply_page }; let text_width = if offset + 4 <= data.len() { HWPUNIT::from(UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])) } else { HWPUNIT::from(0) }; offset += 4; let text_height = if offset + 4 <= data.len() { HWPUNIT::from(UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])) } else { HWPUNIT::from(0) }; offset += 4; let text_ref = if offset < data.len() { data[offset] } else { 0 }; offset += 1; let number_ref = if offset < data.len() { data[offset] } else { 0 }; Ok(CtrlHeaderData::HeaderFooter { attribute, text_width, text_height, text_ref, number_ref, }) }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/ids.rs

crates/hwp-core/src/document/bodytext/ctrl_header/ids.rs

/// 컨트롤 ID 상수 정의 / Control ID constants definition /// /// 스펙 문서 매핑: 표 127 - 개체 이외의 컨트롤과 컨트롤 ID, 표 128 - 필드 컨트롤 ID /// Spec mapping: Table 127 - Controls other than objects and Control IDs, Table 128 - Field Control IDs pub struct CtrlId; impl CtrlId { // 개체 컨트롤 ID / Object Control IDs /// 테이블 컨트롤 / Table control /// 개체 공통 속성을 가지는 컨트롤 ID / Control ID with object common properties pub const TABLE: &str = "tbl "; /// 일반 그리기 개체 / General shape object /// 개체 공통 속성을 가지는 컨트롤 ID / Control ID with object common properties pub const SHAPE_OBJECT: &str = "gso "; // 표 127: 개체 이외의 컨트롤과 컨트롤 ID / Table 127: Controls other than objects and Control IDs /// 구역 정의 / Section definition /// 스펙 문서: 표 127, 표 129 참조 / Spec: See Table 127, Table 129 pub const SECTION_DEF: &str = "secd"; /// 단 정의 / Column definition pub const COLUMN_DEF: &str = "cold"; /// 머리말 / Header pub const HEADER: &str = "head"; /// 꼬리말 / Footer pub const FOOTER: &str = "foot"; /// 각주 / Footnote (공백 포함) pub const FOOTNOTE: &str = "fn "; /// 미주 / Endnote (공백 포함) pub const ENDNOTE: &str = "en "; /// 머리말/꼬리말 (레거시 호환용) / Header/Footer (legacy compatibility) #[deprecated(note = "Use HEADER or FOOTER instead")] pub const HEADER_FOOTER: &str = "head"; /// 자동번호 / Auto numbering /// /// NOTE: /// - 실제 파일/레거시 구현에서 `"atno"`로 나타나는 경우가 있습니다. /// - 따라서 파서는 `"autn"`과 `"atno"` 모두를 자동번호 컨트롤로 처리합니다. pub const AUTO_NUMBER: &str = "autn"; /// 자동번호(대체 CHID) / Auto numbering (alternate CHID) pub const AUTO_NUMBER_ALT: &str = "atno"; /// 새 번호 지정 / New number specification pub const NEW_NUMBER: &str = "newn"; /// 감추기 / Hide pub const HIDE: &str = "pghd"; /// 홀/짝수 조정 / Odd/Even page adjustment pub const PAGE_ADJUST: &str = "pgad"; /// 쪽 번호 위치 / Page number position pub const PAGE_NUMBER: &str = "pgno"; /// 쪽 번호 위치 (pgnp) / Page number position (pgnp) pub const PAGE_NUMBER_POS: &str = "pgnp"; /// 찾아보기 표식 / Bookmark marker pub const BOOKMARK_MARKER: &str = "bkmk"; /// 글자 겹침 / Character overlap pub const OVERLAP: &str = "over"; /// 덧말 / Comment pub const COMMENT: &str = "cmtt"; /// 숨은 설명 / Hidden description pub const HIDDEN_DESC: &str = "hide"; /// 필드 시작 / Field start pub const FIELD_START: &str = "%%%%"; // 표 128: 필드 컨트롤 ID / Table 128: Field Control IDs pub const FIELD_UNKNOWN: &str = "%unk"; pub const FIELD_DATE: &str = "%dte"; pub const FIELD_DOC_DATE: &str = "%ddt"; pub const FIELD_PATH: &str = "%pat"; pub const FIELD_BOOKMARK: &str = "%bmk"; pub const FIELD_CROSS_REF: &str = "%xrf"; pub const FIELD_FORMULA: &str = "%eqr"; pub const FIELD_DOCSUMMARY: &str = "%dsm"; pub const FIELD_USER: &str = "%usr"; pub const FIELD_MAIL_MERGE: &str = "%mmg"; pub const FIELD_HYPERLINK: &str = "%hlk"; pub const FIELD_REVISION: &str = "%rvs"; pub const FIELD_OUTLINE: &str = "%out"; pub const FIELD_TABLE_OF_CONTENTS: &str = "%toc"; pub const FIELD_INDEXMARK: &str = "%idx"; pub const FIELD_PAGECTRL: &str = "%pgc"; pub const FIELD_HWP_SUMMARY: &str = "%hsm"; pub const FIELD_KOGL: &str = "%kgl"; pub const FIELD_GLOSSARY: &str = "%gls"; pub const FIELD_INPUT: &str = "%inp"; pub const FIELD_CHANGE: &str = "%chg"; pub const FIELD_FILE: &str = "%fil"; pub const FIELD_PAGE_NUM: &str = "%pgn"; pub const FIELD_DOC_TITLE: &str = "%ttl"; pub const FIELD_DOC_AUTHOR: &str = "%aut"; pub const FIELD_DOC_KEYWORD: &str = "%key"; pub const FIELD_DOC_SUBJECT: &str = "%sub"; pub const FIELD_DOC_COMMENT: &str = "%cmt"; pub const FIELD_DOC_LASTSAVEDBY: &str = "%lsb"; pub const FIELD_DOC_REVISION: &str = "%rev"; pub const FIELD_DOC_LASTPRINTED: &str = "%lpt"; pub const FIELD_DOC_CREATED: &str = "%crt"; pub const FIELD_DOC_LASTSAVED: &str = "%sav"; pub const FIELD_DOC_PAGECOUNT: &str = "%pgc"; pub const FIELD_DOC_WORDCOUNT: &str = "%wct"; pub const FIELD_DOC_CHARCOUNT: &str = "%cct"; pub const FIELD_PRIVATE_INFO_SECURITY: &str = "%cpr"; pub const FIELD_TABLE_OF_CONTENTS_ALT: &str = "%oc"; }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/types.rs

crates/hwp-core/src/document/bodytext/ctrl_header/types.rs

use crate::types::{HWPUNIT, HWPUNIT16, INT32, INT8, SHWPUNIT, UINT16, UINT32, UINT8}; use serde::{Deserialize, Serialize}; /// 컨트롤 헤더 / Control header #[derive(Debug, Clone, Serialize, Deserialize)] pub struct CtrlHeader { /// 컨트롤 ID (4바이트, ASCII 문자열로 해석 가능) / Control ID (4 bytes, can be interpreted as ASCII string) pub ctrl_id: String, /// 컨트롤 ID 값 (UINT32) / Control ID value (UINT32) pub ctrl_id_value: UINT32, /// 컨트롤 ID 이후의 데이터 (CtrlID에 따라 다름) / Data after control ID (varies by CtrlID) #[serde(flatten)] pub data: CtrlHeaderData, } /// 캡션 정렬 (표 73) / Caption alignment (Table 73) #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum CaptionAlign { Left = 0, Right = 1, Top = 2, Bottom = 3, } /// 캡션 수직 정렬 (ListHeaderProperty bit 5-6) / Caption vertical alignment (ListHeaderProperty bit 5-6) #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum CaptionVAlign { Top = 0, Middle = 1, Bottom = 2, } /// 캡션 정보 (표 72) / Caption information (Table 72) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct Caption { pub align: CaptionAlign, pub include_margin: bool, pub width: HWPUNIT, pub gap: HWPUNIT16, pub last_width: HWPUNIT, #[serde(skip_serializing_if = "Option::is_none")] pub vertical_align: Option<CaptionVAlign>, } /// 컨트롤 헤더 데이터 (컨트롤 ID별 구조) / Control header data (structure varies by CtrlID) #[derive(Debug, Clone, Serialize, Deserialize)] #[serde(tag = "data_type", rename_all = "snake_case")] pub enum CtrlHeaderData { ObjectCommon { attribute: ObjectAttribute, offset_y: SHWPUNIT, offset_x: SHWPUNIT, width: HWPUNIT, height: HWPUNIT, z_order: INT32, margin: Margin, instance_id: UINT32, page_divide: INT32, description: Option<String>, caption: Option<Caption>, }, ColumnDefinition { attribute: ColumnDefinitionAttribute, column_spacing: HWPUNIT16, column_widths: Vec<HWPUNIT16>, attribute_high: UINT16, divider_line_type: UINT8, divider_line_thickness: UINT8, divider_line_color: UINT32, }, FootnoteEndnote { number: UINT8, reserved: [UINT8; 5], attribute: UINT8, reserved2: UINT8, }, HeaderFooter { attribute: HeaderFooterAttribute, text_width: HWPUNIT, text_height: HWPUNIT, text_ref: UINT8, number_ref: UINT8, }, PageNumberPosition { flags: PageNumberPositionFlags, user_symbol: String, prefix: String, suffix: String, }, Field { field_type: String, attribute: UINT32, other_attr: UINT8, command_len: UINT16, command: String, id: UINT32, }, SectionDefinition { attribute: UINT32, column_spacing: HWPUNIT16, vertical_alignment: HWPUNIT16, horizontal_alignment: HWPUNIT16, default_tip_spacing: HWPUNIT, number_para_shape_id: UINT16, page_number: UINT16, figure_number: UINT16, table_number: UINT16, equation_number: UINT16, language: UINT16, }, AutoNumber { attribute: UINT32, number: UINT16, user_symbol: String, prefix: String, suffix: String, }, NewNumber { attribute: UINT32, number: UINT16, }, Hide { attribute: UINT16, }, PageAdjust { attribute: UINT32, }, BookmarkMarker { keyword1: String, keyword2: String, }, Overlap { ctrl_id: String, text: String, border_type: UINT8, internal_text_size: INT8, border_internal_text_spread: UINT8, char_shape_ids: Vec<UINT32>, }, Comment { main_text: String, sub_text: String, position: UINT32, fsize_ratio: UINT32, option: UINT32, style_number: UINT32, alignment: UINT32, }, HiddenDescription, Other, } /// 개체 속성 / Object attribute #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ObjectAttribute { pub like_letters: bool, pub affect_line_spacing: bool, pub vert_rel_to: VertRelTo, pub vert_relative: UINT8, pub horz_rel_to: HorzRelTo, pub horz_relative: UINT8, pub vert_rel_to_para_limit: bool, pub overlap: bool, pub object_width_standard: ObjectWidthStandard, pub object_height_standard: ObjectHeightStandard, pub object_text_option: ObjectTextOption, pub object_text_position_option: ObjectTextPositionOption, pub object_category: ObjectCategory, pub size_protect: bool, } #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum VertRelTo { Paper, Page, Para, } #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum HorzRelTo { Paper, Page, Column, Para, } #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum ObjectWidthStandard { Paper, Page, Column, Para, Absolute, } #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum ObjectHeightStandard { Paper, Page, Absolute, } #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum ObjectTextOption { Square, Tight, Through, TopAndBottom, BehindText, InFrontOfText, } #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum ObjectTextPositionOption { BothSides, LeftOnly, RightOnly, LargestOnly, } #[derive(Debug, Clone, Copy, Serialize, Deserialize)] #[serde(rename_all = "lowercase")] pub enum ObjectCategory { None, Figure, Table, Equation, } /// 단 정의 속성 (표 139) / Column definition attribute (Table 139) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ColumnDefinitionAttribute { pub column_type: ColumnType, pub column_count: UINT8, pub column_direction: ColumnDirection, pub equal_width: bool, } #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum ColumnType { Normal, Distributed, Parallel, } #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum ColumnDirection { Left, Right, Both, } /// 오브젝트의 바깥 4방향 여백 / Object outer margins (4 directions) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct Margin { pub top: HWPUNIT16, pub right: HWPUNIT16, pub bottom: HWPUNIT16, pub left: HWPUNIT16, } /// 쪽 번호 위치 속성 (표 148) / Page number position attributes (Table 148) #[derive(Debug, Clone, Serialize, Deserialize)] pub struct PageNumberPositionFlags { pub shape: u8, pub position: PageNumberPosition, } /// 쪽 번호의 표시 위치 / Page number display position #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum PageNumberPosition { None, TopLeft, TopCenter, TopRight, BottomLeft, BottomCenter, BottomRight, OutsideTop, OutsideBottom, InsideTop, InsideBottom, } /// 머리말/꼬리말 속성 (표 141) / Header/Footer attribute (Table 141) #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct HeaderFooterAttribute { pub apply_page: ApplyPage, } #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "snake_case")] pub enum ApplyPage { Both, EvenOnly, OddOnly, }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/overlap.rs

crates/hwp-core/src/document/bodytext/ctrl_header/overlap.rs

use crate::error::HwpError; use crate::types::decode_utf16le; use crate::types::{INT8, UINT16, UINT32, UINT8}; use super::types::CtrlHeaderData; /// 글자 겹침 파싱 (표 150) / Parse character overlap (Table 150) pub(crate) fn parse_overlap(data: &[u8]) -> Result<CtrlHeaderData, HwpError> { if data.len() < 10 { return Err(HwpError::insufficient_data("Overlap", 10, data.len())); } let mut offset = 0usize; let ctrl_id_bytes = [data[offset + 3], data[offset + 2], data[offset + 1], data[offset]]; let ctrl_id = String::from_utf8_lossy(&ctrl_id_bytes) .trim_end_matches('\0') .to_string(); offset += 4; let text_len = UINT16::from_le_bytes([data[offset], data[offset + 1]]) as usize; offset += 2; let text = if text_len > 0 && offset + (text_len * 2) <= data.len() { let text_bytes = &data[offset..offset + (text_len * 2)]; decode_utf16le(text_bytes).unwrap_or_default() } else { String::new() }; offset += text_len * 2; let border_type = if offset < data.len() { UINT8::from_le_bytes([data[offset]]) } else { 0 }; offset += 1; let internal_text_size = if offset < data.len() { INT8::from_le_bytes([data[offset]]) } else { 0 }; offset += 1; let border_internal_text_spread = if offset < data.len() { UINT8::from_le_bytes([data[offset]]) } else { 0 }; offset += 1; let cnt = if offset < data.len() { UINT8::from_le_bytes([data[offset]]) as usize } else { 0 }; offset += 1; let mut char_shape_ids = Vec::new(); if cnt > 0 && offset + (cnt * 4) <= data.len() { for _ in 0..cnt { let id = UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]); char_shape_ids.push(id); offset += 4; } } Ok(CtrlHeaderData::Overlap { ctrl_id, text, border_type, internal_text_size, border_internal_text_spread, char_shape_ids, }) }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/mod.rs

crates/hwp-core/src/document/bodytext/ctrl_header/mod.rs

// CtrlHeader parsing/types split into modules. mod ids; mod types; mod auto_number; mod bookmark_marker; mod caption; mod column_definition; mod comment; mod field; mod footnote_endnote; mod header_footer; mod hide; mod object_common; mod overlap; mod page_adjust; mod page_number_position; mod section_definition; pub use ids::CtrlId; pub use types::*; pub use caption::parse_caption_from_list_header; use crate::error::HwpError; use crate::types::UINT32; impl CtrlHeader { /// CtrlHeader를 바이트 배열에서 파싱합니다. / Parse CtrlHeader from byte array. pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 4 { return Err(HwpError::insufficient_data("CtrlHeader", 4, data.len())); } let ctrl_id_value = UINT32::from_le_bytes([data[0], data[1], data[2], data[3]]); // pyhwp처럼 바이트를 리버스해서 읽음 / Read bytes in reverse order like pyhwp let ctrl_id_bytes = [data[3], data[2], data[1], data[0]]; // 공백까지 포함해서 파싱 (trim_end 제거) / Parse including spaces (remove trim_end) let ctrl_id = String::from_utf8_lossy(&ctrl_id_bytes) .trim_end_matches('\0') .to_string(); let remaining_data = if data.len() > 4 { &data[4..] } else { &[] }; let parsed_data = match ctrl_id.as_str() { CtrlId::TABLE | CtrlId::SHAPE_OBJECT => object_common::parse_object_common(remaining_data)?, CtrlId::COLUMN_DEF => column_definition::parse_column_definition(remaining_data)?, CtrlId::FOOTNOTE | CtrlId::ENDNOTE => footnote_endnote::parse_footnote_endnote(remaining_data)?, CtrlId::HEADER | CtrlId::FOOTER => header_footer::parse_header_footer(remaining_data)?, CtrlId::PAGE_NUMBER | CtrlId::PAGE_NUMBER_POS => { page_number_position::parse_page_number_position(remaining_data)? } CtrlId::FIELD_START => field::parse_field(remaining_data)?, CtrlId::SECTION_DEF => section_definition::parse_section_definition(remaining_data)?, CtrlId::AUTO_NUMBER | CtrlId::AUTO_NUMBER_ALT => auto_number::parse_auto_number(remaining_data)?, CtrlId::NEW_NUMBER => auto_number::parse_new_number(remaining_data)?, CtrlId::HIDE => hide::parse_hide(remaining_data)?, CtrlId::PAGE_ADJUST => page_adjust::parse_page_adjust(remaining_data)?, CtrlId::BOOKMARK_MARKER => bookmark_marker::parse_bookmark_marker(remaining_data)?, CtrlId::OVERLAP => overlap::parse_overlap(remaining_data)?, CtrlId::COMMENT => comment::parse_comment(remaining_data)?, CtrlId::HIDDEN_DESC => CtrlHeaderData::HiddenDescription, _ => CtrlHeaderData::Other, }; Ok(CtrlHeader { ctrl_id, ctrl_id_value, data: parsed_data, }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/column_definition.rs

crates/hwp-core/src/document/bodytext/ctrl_header/column_definition.rs

use crate::error::HwpError; use crate::types::{HWPUNIT16, UINT16, UINT32, UINT8}; use super::types::{ColumnDefinitionAttribute, ColumnDirection, ColumnType, CtrlHeaderData}; /// 단 정의 파싱 (표 138) / Parse column definition (Table 138) pub(crate) fn parse_column_definition(data: &[u8]) -> Result<CtrlHeaderData, HwpError> { if data.len() < 12 { return Err(HwpError::insufficient_data( "Column definition", 12, data.len(), )); } let mut offset = 0usize; let attribute_low = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let column_type = match attribute_low & 0x03 { 0 => ColumnType::Normal, 1 => ColumnType::Distributed, 2 => ColumnType::Parallel, _ => ColumnType::Normal, }; let column_count = ((attribute_low >> 2) & 0xFF) as UINT8; let column_count_u8 = if column_count == 0 { 1 } else { column_count }; let column_direction = match (attribute_low >> 10) & 0x03 { 0 => ColumnDirection::Left, 1 => ColumnDirection::Right, 2 => ColumnDirection::Both, _ => ColumnDirection::Left, }; let equal_width = (attribute_low & 0x1000) != 0; let attribute = ColumnDefinitionAttribute { column_type, column_count: column_count_u8, column_direction, equal_width, }; let column_spacing = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let mut column_widths = Vec::new(); if !equal_width { for _ in 0..column_count_u8 { if offset + 2 <= data.len() { column_widths.push(HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]])); offset += 2; } else { break; } } } let attribute_high = if offset + 2 <= data.len() { UINT16::from_le_bytes([data[offset], data[offset + 1]]) } else { 0 }; offset += 2; let divider_line_type = if offset < data.len() { data[offset] } else { 0 }; offset += 1; let divider_line_thickness = if offset < data.len() { data[offset] } else { 0 }; offset += 1; let divider_line_color = if offset + 4 <= data.len() { UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]) } else { 0 }; Ok(CtrlHeaderData::ColumnDefinition { attribute, column_spacing, column_widths, attribute_high, divider_line_type, divider_line_thickness, divider_line_color, }) }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/page_adjust.rs

crates/hwp-core/src/document/bodytext/ctrl_header/page_adjust.rs

use crate::error::HwpError; use crate::types::UINT32; use super::types::CtrlHeaderData; /// 홀/짝수 조정 파싱 (표 146) / Parse page adjustment (Table 146) pub(crate) fn parse_page_adjust(data: &[u8]) -> Result<CtrlHeaderData, HwpError> { if data.len() < 4 { return Err(HwpError::insufficient_data("Page adjust", 4, data.len())); } let attribute = UINT32::from_le_bytes([data[0], data[1], data[2], data[3]]); Ok(CtrlHeaderData::PageAdjust { attribute }) }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/auto_number.rs

crates/hwp-core/src/document/bodytext/ctrl_header/auto_number.rs

use crate::error::HwpError; use crate::types::decode_utf16le; use crate::types::{UINT16, UINT32}; use super::types::CtrlHeaderData; /// 자동번호 파싱 (표 142) / Parse auto number (Table 142) pub(crate) fn parse_auto_number(data: &[u8]) -> Result<CtrlHeaderData, HwpError> { if data.len() < 12 { return Err(HwpError::insufficient_data("Auto number", 12, data.len())); } let mut offset = 0usize; let attribute = UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]); offset += 4; let number = UINT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let user_symbol = decode_utf16le(&data[offset..offset + 2]).unwrap_or_default(); offset += 2; let prefix = decode_utf16le(&data[offset..offset + 2]).unwrap_or_default(); offset += 2; let suffix = decode_utf16le(&data[offset..offset + 2]).unwrap_or_default(); Ok(CtrlHeaderData::AutoNumber { attribute, number, user_symbol, prefix, suffix, }) } /// 새 번호 지정 파싱 (표 144) / Parse new number specification (Table 144) pub(crate) fn parse_new_number(data: &[u8]) -> Result<CtrlHeaderData, HwpError> { if data.len() < 8 { return Err(HwpError::insufficient_data("New number", 8, data.len())); } let mut offset = 0usize; let attribute = UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]); offset += 4; let number = UINT16::from_le_bytes([data[offset], data[offset + 1]]); Ok(CtrlHeaderData::NewNumber { attribute, number }) }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/section_definition.rs

crates/hwp-core/src/document/bodytext/ctrl_header/section_definition.rs

use crate::error::HwpError; use crate::types::{HWPUNIT, HWPUNIT16, UINT16, UINT32}; use super::types::CtrlHeaderData; /// 구역 정의 파싱 (표 129) / Parse section definition (Table 129) pub(crate) fn parse_section_definition(data: &[u8]) -> Result<CtrlHeaderData, HwpError> { if data.len() < 24 { return Err(HwpError::insufficient_data( "Section definition", 24, data.len(), )); } let mut offset = 0usize; let attribute = UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]); offset += 4; let column_spacing = if offset + 2 <= data.len() { HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]) } else { 0 }; offset += 2; let vertical_alignment = if offset + 2 <= data.len() { HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]) } else { 0 }; offset += 2; let horizontal_alignment = if offset + 2 <= data.len() { HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]) } else { 0 }; offset += 2; let default_tip_spacing = if offset + 4 <= data.len() { HWPUNIT::from(UINT32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ])) } else { HWPUNIT::from(0) }; offset += 4; let number_para_shape_id = if offset + 2 <= data.len() { UINT16::from_le_bytes([data[offset], data[offset + 1]]) } else { 0 }; offset += 2; let page_number = if offset + 2 <= data.len() { UINT16::from_le_bytes([data[offset], data[offset + 1]]) } else { 0 }; offset += 2; let figure_number = if offset + 2 <= data.len() { UINT16::from_le_bytes([data[offset], data[offset + 1]]) } else { 0 }; offset += 2; let table_number = if offset + 2 <= data.len() { UINT16::from_le_bytes([data[offset], data[offset + 1]]) } else { 0 }; offset += 2; let equation_number = if offset + 2 <= data.len() { UINT16::from_le_bytes([data[offset], data[offset + 1]]) } else { 0 }; offset += 2; let language = if offset + 2 <= data.len() { UINT16::from_le_bytes([data[offset], data[offset + 1]]) } else { 0 }; Ok(CtrlHeaderData::SectionDefinition { attribute, column_spacing, vertical_alignment, horizontal_alignment, default_tip_spacing, number_para_shape_id, page_number, figure_number, table_number, equation_number, language, }) }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/caption.rs

crates/hwp-core/src/document/bodytext/ctrl_header/caption.rs

use crate::error::HwpError; use crate::types::{HWPUNIT, HWPUNIT16, UINT32}; // keep use super::types::{Caption, CaptionAlign, CaptionVAlign}; /// LIST_HEADER 레코드에서 캡션 파싱 (hwplib 방식) / Parse caption from LIST_HEADER record (hwplib approach) pub fn parse_caption_from_list_header(data: &[u8]) -> Result<Option<Caption>, HwpError> { if data.len() < 22 { return Ok(None); } let mut offset = 0usize; // paraCount (SInt4) - 4 bytes (read but not used) offset += 4; let list_header_property = UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]); offset += 4; let vertical_align = match (list_header_property >> 5) & 0x03 { 0 => CaptionVAlign::Top, 1 => CaptionVAlign::Middle, 2 => CaptionVAlign::Bottom, _ => CaptionVAlign::Middle, }; let caption_property_value = UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]); offset += 4; let align = match caption_property_value & 0x03 { 0 => CaptionAlign::Left, 1 => CaptionAlign::Right, 2 => CaptionAlign::Top, 3 => CaptionAlign::Bottom, _ => CaptionAlign::Bottom, }; let include_margin = (caption_property_value & 0x04) != 0; let width = HWPUNIT::from(UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]])); offset += 4; let gap = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let last_width = HWPUNIT::from(UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]])); Ok(Some(Caption { align, include_margin, width, gap, last_width, vertical_align: Some(vertical_align), })) } /// 캡션 파싱 (표 72 - 14바이트) / Parse caption (Table 72 - 14 bytes) #[allow(dead_code)] fn parse_caption(data: &[u8]) -> Result<Caption, HwpError> { if data.len() < 14 { return Err(HwpError::insufficient_data("Caption", 14, data.len())); } let mut offset = 0usize; let attribute_value = UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]); offset += 4; let align = match attribute_value & 0x03 { 0 => CaptionAlign::Left, 1 => CaptionAlign::Right, 2 => CaptionAlign::Top, 3 => CaptionAlign::Bottom, _ => CaptionAlign::Bottom, }; let include_margin = (attribute_value & 0x04) != 0; let width = HWPUNIT::from(UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]])); offset += 4; let gap = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let last_width = HWPUNIT::from(UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]])); Ok(Caption { align, include_margin, width, gap, last_width, vertical_align: None, }) } /// 캡션 파싱 (표 72 - 12바이트 버전) / Parse caption (Table 72 - 12 bytes version) #[allow(dead_code)] fn parse_caption_12bytes(data: &[u8]) -> Result<Caption, HwpError> { if data.len() < 12 { return Err(HwpError::insufficient_data( "Caption (12 bytes)", 12, data.len(), )); } let mut offset = 0usize; let attribute_value = UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]); offset += 4; let align = match attribute_value & 0x03 { 0 => CaptionAlign::Left, 1 => CaptionAlign::Right, 2 => CaptionAlign::Top, 3 => CaptionAlign::Bottom, _ => CaptionAlign::Bottom, }; let include_margin = (attribute_value & 0x04) != 0; let width = HWPUNIT::from(UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]])); offset += 4; let gap = HWPUNIT16::from_le_bytes([data[offset], data[offset + 1]]); let last_width = HWPUNIT::from(0); Ok(Caption { align, include_margin, width, gap, last_width, vertical_align: None, }) }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bodytext/ctrl_header/comment.rs

crates/hwp-core/src/document/bodytext/ctrl_header/comment.rs

use crate::error::HwpError; use crate::types::decode_utf16le; use crate::types::{UINT16, UINT32}; use super::types::CtrlHeaderData; /// 덧말 파싱 (표 151) / Parse comment (Table 151) pub(crate) fn parse_comment(data: &[u8]) -> Result<CtrlHeaderData, HwpError> { if data.len() < 18 { return Err(HwpError::insufficient_data("Comment", 18, data.len())); } let mut offset = 0usize; let main_text_len = UINT16::from_le_bytes([data[offset], data[offset + 1]]) as usize; offset += 2; let main_text = if main_text_len > 0 && offset + (main_text_len * 2) <= data.len() { let main_text_bytes = &data[offset..offset + (main_text_len * 2)]; decode_utf16le(main_text_bytes).unwrap_or_default() } else { String::new() }; offset += main_text_len.max(1) * 2; let sub_text_len = if offset + 2 <= data.len() { UINT16::from_le_bytes([data[offset], data[offset + 1]]) as usize } else { 0 }; offset += 2; let sub_text = if sub_text_len > 0 && offset + (sub_text_len * 2) <= data.len() { let sub_text_bytes = &data[offset..offset + (sub_text_len * 2)]; decode_utf16le(sub_text_bytes).unwrap_or_default() } else { String::new() }; offset += sub_text_len.max(1) * 2; let position = if offset + 4 <= data.len() { UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]) } else { 0 }; offset += 4; let fsize_ratio = if offset + 4 <= data.len() { UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]) } else { 0 }; offset += 4; let option = if offset + 4 <= data.len() { UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]) } else { 0 }; offset += 4; let style_number = if offset + 4 <= data.len() { UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]) } else { 0 }; offset += 4; let alignment = if offset + 4 <= data.len() { UINT32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]) } else { 0 }; Ok(CtrlHeaderData::Comment { main_text, sub_text, position, fsize_ratio, option, style_number, alignment, }) }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/bindata/mod.rs

crates/hwp-core/src/document/bindata/mod.rs

/// BinData parsing module /// /// This module handles parsing of HWP BinData storage. /// /// 스펙 문서 매핑: 표 2 - 바이너리 데이터 (BinData 스토리지) use crate::decompress::decompress_deflate; use crate::document::docinfo::BinDataRecord; use crate::error::HwpError; use crate::types::WORD; use base64::{engine::general_purpose::STANDARD, Engine as _}; use cfb::CompoundFile; use serde::{Deserialize, Serialize}; use std::io::{Cursor, Read}; use std::path::Path; /// Binary data output format /// 바이너리 데이터 출력 형식 #[derive(Debug, Clone)] pub enum BinaryDataFormat { /// Base64 encoded string / Base64로 인코딩된 문자열 Base64, /// File path where binary data is saved / 바이너리 데이터가 저장된 파일 경로 File(String), } /// Binary data structure #[derive(Debug, Clone, Default, Serialize, Deserialize)] pub struct BinData { /// Binary data items (BinaryData0, BinaryData1, etc.) pub items: Vec<BinaryDataItem>, } /// Binary data item #[derive(Debug, Clone, Default, Serialize, Deserialize)] pub struct BinaryDataItem { /// Item index pub index: WORD, /// Base64 encoded data or file path / Base64로 인코딩된 데이터 또는 파일 경로 pub data: String, } impl BinData { /// Parse BinData storage from CFB structure /// CFB 구조에서 BinData 스토리지를 파싱합니다. /// /// # Arguments /// * `cfb` - CompoundFile structure (mutable reference required) / CompoundFile 구조체 (가변 참조 필요) /// * `output_format` - Output format for binary data / 바이너리 데이터 출력 형식 /// * `bin_data_records` - BinData records from DocInfo (표 17) / DocInfo의 BinData 레코드 (표 17) /// /// # Returns /// Parsed BinData structure / 파싱된 BinData 구조체 /// /// # Notes /// 표 17의 HWPTAG_BIN_DATA 레코드에서 EMBEDDING 타입인 경우 `binary_data_id`와 `extension` 정보를 사용합니다. /// When BinDataRecord type is EMBEDDING, we use `binary_data_id` and `extension` from Table 17. pub fn parse( cfb: &mut CompoundFile<Cursor<&[u8]>>, output_format: BinaryDataFormat, bin_data_records: &[BinDataRecord], ) -> Result<Self, HwpError> { let mut items = Vec::new(); // 표 17의 bin_data_records를 사용하여 스트림을 찾습니다 (EMBEDDING/STORAGE 타입만) // Use bin_data_records from Table 17 to find streams (only EMBEDDING/STORAGE types) for record in bin_data_records { let (binary_data_id, extension_opt) = match record { BinDataRecord::Embedding { embedding, .. } => { (embedding.binary_data_id, Some(embedding.extension.clone())) } BinDataRecord::Storage { storage, .. } => (storage.binary_data_id, None), BinDataRecord::Link { .. } => { // LINK 타입은 BinData 스토리지에 없으므로 건너뜀 // LINK type is not in BinData storage, so skip continue; } }; let base_stream_name = format!("BIN{:04X}", binary_data_id); // Try different path formats // 다양한 경로 형식 시도 let mut paths = vec![ format!("BinData/{}", base_stream_name), format!("Root Entry/BinData/{}", base_stream_name), base_stream_name.clone(), ]; // 표 17의 extension 정보가 있으면 확장자 포함 경로도 시도 // If extension info from Table 17 exists, also try paths with extension if let Some(ext) = &extension_opt { paths.push(format!("BinData/{}.{}", base_stream_name, ext)); paths.push(format!("Root Entry/BinData/{}.{}", base_stream_name, ext)); } let mut found = false; for path in &paths { match cfb.open_stream(path) { Ok(mut stream) => { let mut buffer = Vec::new(); match stream.read_to_end(&mut buffer) { Ok(_) => { if !buffer.is_empty() { // BinData 스트림은 압축되어 있으므로 압축 해제 필요 // BinData streams are compressed, so decompression is required // 레거시 코드 참고: hwpjs.js는 pako.inflate(..., { windowBits: -15 }) // pyhwp는 zlib.decompress(..., -15) 사용 // Reference: hwpjs.js uses pako.inflate(..., { windowBits: -15 }) // pyhwp uses zlib.decompress(..., -15) let _compressed_size = buffer.len(); let decompressed_buffer = match decompress_deflate(&buffer) { Ok(decompressed) => decompressed, Err(e) => { #[cfg(debug_assertions)] eprintln!( "Warning: Failed to decompress BinData stream '{}' (id={}): {}. Using raw data.", path, binary_data_id, e ); buffer.clone() // 압축 해제 실패 시 원본 데이터 사용 } }; let data = match &output_format { BinaryDataFormat::Base64 => { STANDARD.encode(&decompressed_buffer) } BinaryDataFormat::File(dir_path) => { let ext = extension_opt.as_deref().unwrap_or("bin"); let file_name = format!("{}.{}", base_stream_name, ext); let file_path = Path::new(dir_path).join(&file_name); std::fs::create_dir_all(dir_path).map_err(|e| { format!( "Failed to create directory '{}': {}", dir_path, e ) })?; std::fs::write(&file_path, &decompressed_buffer) .map_err(|e| { format!( "Failed to write file '{}': {}", file_path.display(), e ) })?; file_path.to_string_lossy().to_string() } }; items.push(BinaryDataItem { index: binary_data_id, data, }); found = true; break; } } Err(_) => continue, } } Err(_) => continue, } } if !found { // 스트림을 찾지 못했지만 계속 진행 (다른 레코드는 있을 수 있음) // Stream not found, but continue (other records may exist) } } Ok(BinData { items }) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/fileheader/serialize.rs

crates/hwp-core/src/document/fileheader/serialize.rs

use crate::types::DWORD; use serde::Serializer; use super::constants::{document_flags, license_flags}; /// Serialize version DWORD as "M.n.P.r" format string pub fn serialize_version<S>(version: &DWORD, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, { serializer.serialize_str(&format_version(*version)) } /// Format version DWORD to "M.n.P.r" string /// Format: 0xMMnnPPrr (e.g., 0x05000300 = "5.0.3.0") fn format_version(version: DWORD) -> String { let major = (version >> 24) & 0xFF; let minor = (version >> 16) & 0xFF; let patch = (version >> 8) & 0xFF; let revision = version & 0xFF; format!("{}.{}.{}.{}", major, minor, patch, revision) } /// Serialize document_flags DWORD as array of flag constants pub fn serialize_document_flags<S>(flags: &DWORD, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, { use serde::ser::SerializeSeq; let mut active_flags = Vec::new(); if (*flags & 0x01) != 0 { active_flags.push(document_flags::COMPRESSED); } if (*flags & 0x02) != 0 { active_flags.push(document_flags::ENCRYPTED); } if (*flags & 0x04) != 0 { active_flags.push(document_flags::DISTRIBUTION); } if (*flags & 0x08) != 0 { active_flags.push(document_flags::SCRIPT); } if (*flags & 0x10) != 0 { active_flags.push(document_flags::DRM); } if (*flags & 0x20) != 0 { active_flags.push(document_flags::XML_TEMPLATE); } if (*flags & 0x40) != 0 { active_flags.push(document_flags::HISTORY); } if (*flags & 0x80) != 0 { active_flags.push(document_flags::ELECTRONIC_SIGNATURE); } if (*flags & 0x100) != 0 { active_flags.push(document_flags::CERTIFICATE_ENCRYPTION); } if (*flags & 0x200) != 0 { active_flags.push(document_flags::SIGNATURE_PREVIEW); } if (*flags & 0x400) != 0 { active_flags.push(document_flags::CERTIFICATE_DRM); } if (*flags & 0x800) != 0 { active_flags.push(document_flags::CCL); } if (*flags & 0x1000) != 0 { active_flags.push(document_flags::MOBILE_OPTIMIZED); } if (*flags & 0x2000) != 0 { active_flags.push(document_flags::PRIVACY_SECURITY); } if (*flags & 0x4000) != 0 { active_flags.push(document_flags::TRACK_CHANGE); } if (*flags & 0x8000) != 0 { active_flags.push(document_flags::KOGL); } if (*flags & 0x10000) != 0 { active_flags.push(document_flags::VIDEO_CONTROL); } if (*flags & 0x20000) != 0 { active_flags.push(document_flags::TABLE_OF_CONTENTS); } let mut seq = serializer.serialize_seq(Some(active_flags.len()))?; for flag in active_flags { seq.serialize_element(flag)?; } seq.end() } /// Serialize license_flags DWORD as array of flag constants pub fn serialize_license_flags<S>(flags: &DWORD, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer, { use serde::ser::SerializeSeq; let mut active_flags = Vec::new(); if (*flags & 0x01) != 0 { active_flags.push(license_flags::CCL_KOGL); } if (*flags & 0x02) != 0 { active_flags.push(license_flags::COPY_RESTRICTED); } if (*flags & 0x04) != 0 { active_flags.push(license_flags::COPY_ALLOWED_SAME_CONDITION); } let mut seq = serializer.serialize_seq(Some(active_flags.len()))?; for flag in active_flags { seq.serialize_element(flag)?; } seq.end() }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/fileheader/mod.rs

crates/hwp-core/src/document/fileheader/mod.rs

/// FileHeader parsing module /// /// This module handles parsing of HWP FileHeader structure. /// According to HWP 5.0 spec, FileHeader is 256 bytes. /// /// 스펙 문서 매핑: 표 2 - 파일 인식 정보 (FileHeader 스트림) use crate::error::HwpError; use crate::types::{BYTE, DWORD}; use serde::{Deserialize, Serialize}; mod constants; mod serialize; use serialize::{serialize_document_flags, serialize_license_flags, serialize_version}; /// FileHeader structure for HWP 5.0 #[derive(Debug, Clone, Serialize, Deserialize)] pub struct FileHeader { /// Signature: "HWP Document File" (32 bytes) pub signature: String, /// File version (4 bytes, DWORD) /// Format: 0xMMnnPPrr (e.g., 0x05000300 = 5.0.3.0) #[serde(serialize_with = "serialize_version")] pub version: DWORD, /// Document flags (4 bytes, DWORD) /// Bit flags: compression, encryption, distribution, script, DRM, electronic signature, etc. #[serde(serialize_with = "serialize_document_flags")] pub document_flags: DWORD, /// License flags (4 bytes, DWORD) /// Bit flags: CCL, KOGL license, copy restriction, etc. #[serde(serialize_with = "serialize_license_flags")] pub license_flags: DWORD, /// Encryption version (4 bytes, DWORD) pub encrypt_version: DWORD, /// KOGL license country (1 byte, BYTE) pub kogl_country: BYTE, /// Reserved (207 bytes) - excluded from JSON serialization #[serde(skip_serializing)] pub reserved: Vec<u8>, } impl FileHeader { /// Parse FileHeader from byte array /// /// # Arguments /// * `data` - 256-byte FileHeader data /// /// # Returns /// Parsed FileHeader structure pub fn parse(data: &[u8]) -> Result<Self, HwpError> { if data.len() < 256 { return Err(HwpError::insufficient_data("FileHeader", 256, data.len())); } // Parse signature (32 bytes) let signature_bytes = &data[0..32]; let signature = String::from_utf8_lossy(signature_bytes) .trim_end_matches('\0') .to_string(); // Validate signature if signature != "HWP Document File" { return Err(HwpError::InvalidSignature { found: signature }); } // Parse version (4 bytes, DWORD, little-endian) let version = DWORD::from_le_bytes([data[32], data[33], data[34], data[35]]); // Parse document_flags (4 bytes, DWORD, little-endian) let document_flags = DWORD::from_le_bytes([data[36], data[37], data[38], data[39]]); // Parse license_flags (4 bytes, DWORD, little-endian) let license_flags = DWORD::from_le_bytes([data[40], data[41], data[42], data[43]]); // Parse encrypt_version (4 bytes, DWORD, little-endian) let encrypt_version = DWORD::from_le_bytes([data[44], data[45], data[46], data[47]]); // Parse kogl_country (1 byte, BYTE) let kogl_country = data[48]; // Parse reserved (207 bytes) let reserved = data[49..256].to_vec(); Ok(FileHeader { signature, version, document_flags, license_flags, encrypt_version, kogl_country, reserved, }) } /// Check if file is compressed pub fn is_compressed(&self) -> bool { (self.document_flags & 0x01) != 0 } /// Check if file is encrypted pub fn is_encrypted(&self) -> bool { (self.document_flags & 0x02) != 0 } /// Check if XMLTemplate storage exists /// XMLTemplate 스토리지 존재 여부 확인 pub fn has_xml_template(&self) -> bool { (self.document_flags & 0x20) != 0 // Bit 5 } /// Convert FileHeader to JSON string pub fn to_json(&self) -> Result<String, HwpError> { serde_json::to_string_pretty(self).map_err(HwpError::from) } /// Get version as string (e.g., "5.0.3.0") pub fn version_string(&self) -> String { let major = (self.version >> 24) & 0xFF; let minor = (self.version >> 16) & 0xFF; let patch = (self.version >> 8) & 0xFF; let revision = self.version & 0xFF; format!("{}.{}.{}.{}", major, minor, patch, revision) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/src/document/fileheader/constants.rs

crates/hwp-core/src/document/fileheader/constants.rs

/// Document flag constants /// /// 스펙 문서 매핑: 표 3 - 속성 (첫 번째 DWORD) pub mod document_flags { /// Bit 0: 압축 여부 pub const COMPRESSED: &str = "compressed"; /// Bit 1: 암호 설정 여부 pub const ENCRYPTED: &str = "encrypted"; /// Bit 2: 배포용 문서 여부 pub const DISTRIBUTION: &str = "distribution"; /// Bit 3: 스크립트 저장 여부 pub const SCRIPT: &str = "script"; /// Bit 4: DRM 보안 문서 여부 pub const DRM: &str = "drm"; /// Bit 5: XMLTemplate 스토리지 존재 여부 pub const XML_TEMPLATE: &str = "xml_template"; /// Bit 6: 문서 이력 관리 존재 여부 pub const HISTORY: &str = "history"; /// Bit 7: 전자 서명 정보 존재 여부 pub const ELECTRONIC_SIGNATURE: &str = "electronic_signature"; /// Bit 8: 공인 인증서 암호화 여부 pub const CERTIFICATE_ENCRYPTION: &str = "certificate_encryption"; /// Bit 9: 전자 서명 예비 저장 여부 pub const SIGNATURE_PREVIEW: &str = "signature_preview"; /// Bit 10: 공인 인증서 DRM 보안 문서 여부 pub const CERTIFICATE_DRM: &str = "certificate_drm"; /// Bit 11: CCL 문서 여부 pub const CCL: &str = "ccl"; /// Bit 12: 모바일 최적화 여부 pub const MOBILE_OPTIMIZED: &str = "mobile_optimized"; /// Bit 13: 개인 정보 보안 문서 여부 pub const PRIVACY_SECURITY: &str = "privacy_security"; /// Bit 14: 변경 추적 문서 여부 pub const TRACK_CHANGE: &str = "track_change"; /// Bit 15: 공공누리(KOGL) 저작권 문서 pub const KOGL: &str = "kogl"; /// Bit 16: 비디오 컨트롤 포함 여부 pub const VIDEO_CONTROL: &str = "video_control"; /// Bit 17: 차례 필드 컨트롤 포함 여부 pub const TABLE_OF_CONTENTS: &str = "table_of_contents"; } /// License flag constants /// /// 스펙 문서 매핑: 표 3 - 속성 (두 번째 DWORD) pub mod license_flags { /// Bit 0: CCL, 공공누리 라이선스 정보 pub const CCL_KOGL: &str = "ccl_kogl"; /// Bit 1: 복제 제한 여부 pub const COPY_RESTRICTED: &str = "copy_restricted"; /// Bit 2: 동일 조건 하에 복제 허가 여부 (복제 제한인 경우 무시) pub const COPY_ALLOWED_SAME_CONDITION: &str = "copy_allowed_same_condition"; }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/tests/parser_tests.rs

crates/hwp-core/tests/parser_tests.rs

/// HwpParser 테스트 /// HwpParser tests mod common; use hwp_core::*; #[test] fn test_hwp_parser_new() { let _parser = HwpParser::new(); } #[test] fn test_hwp_parser_parse_with_actual_file() { // Test with actual HWP file if available use crate::common::find_fixture_file; if let Some(path) = find_fixture_file("noori.hwp") { if let Ok(data) = std::fs::read(path) { let parser = HwpParser::new(); let result = parser.parse(&data); if let Err(e) = &result { eprintln!("Parse error: {}", e); } assert!(result.is_ok(), "Should parse actual HWP file"); let document = result.unwrap(); // Validate document structure assert_eq!( document.file_header.signature.trim_end_matches('\0'), "HWP Document File" ); assert!(document.file_header.version > 0); } } } #[test] fn test_hwp_parser_parse_fileheader_json() { // Test FileHeader JSON output use crate::common::find_fixture_file; if let Some(path) = find_fixture_file("noori.hwp") { if let Ok(data) = std::fs::read(path) { let parser = HwpParser::new(); let result = parser.parse_fileheader_json(&data); assert!(result.is_ok(), "Should return FileHeader as JSON"); let json = result.unwrap(); // Validate JSON contains expected fields assert!(json.contains("signature")); assert!(json.contains("version")); assert!(json.contains("document_flags")); assert!(json.contains("license_flags")); assert!(json.contains("encrypt_version")); assert!(json.contains("kogl_country")); } } } #[test] fn test_hwp_parser_parse_with_invalid_data() { let parser = HwpParser::new(); let data = b"invalid hwp file content"; let result = parser.parse(data); // Should fail because it's not a valid CFB structure assert!(result.is_err(), "Should fail for invalid CFB data"); }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/tests/fileheader_tests.rs

crates/hwp-core/tests/fileheader_tests.rs

/// FileHeader 파싱 테스트 /// FileHeader parsing tests mod common; use hwp_core::*; #[test] fn test_fileheader_parse_basic() { // Create a minimal valid FileHeader let mut data = vec![0u8; 256]; // Set signature "HWP Document File" let signature = b"HWP Document File\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"; data[0..signature.len()].copy_from_slice(signature); // Set version (5.0.3.0 = 0x05000300) data[32..36].copy_from_slice(&0x05000300u32.to_le_bytes()); // Set document_flags (compressed flag) data[36..40].copy_from_slice(&0x01u32.to_le_bytes()); let fileheader = FileHeader::parse(&data).expect("Should parse FileHeader"); assert_eq!( fileheader.signature.trim_end_matches('\0'), "HWP Document File" ); assert_eq!(fileheader.version, 0x05000300); assert!(fileheader.is_compressed()); } #[test] fn test_fileheader_parse_too_short() { let data = vec![0u8; 100]; let result = FileHeader::parse(&data); assert!( result.is_err(), "Should fail for data shorter than 256 bytes" ); } #[test] fn test_fileheader_parse_from_actual_file() { // Test with actual HWP file if available use crate::common::find_fixture_file; let file_path = match find_fixture_file("noori.hwp") { Some(p) => p, None => { println!("HWP test file not found in fixtures directory"); return; } }; match std::fs::read(file_path) { Ok(data) => { let mut cfb = CfbParser::parse(&data).expect("Should parse CFB"); match CfbParser::read_stream(&mut cfb, "FileHeader") { Ok(fileheader_data) => { let fileheader = FileHeader::parse(&fileheader_data) .expect("Should parse FileHeader from actual file"); // Validate signature (must be exactly "HWP Document File") let signature_trimmed = fileheader.signature.trim_end_matches('\0'); assert_eq!( signature_trimmed, "HWP Document File", "Signature must be 'HWP Document File'" ); // Validate signature bytes (original data should be 32 bytes) // The signature field is a String, but we check the original bytes let signature_bytes = &fileheader_data[0..32]; assert_eq!( signature_bytes.len(), 32, "Signature bytes must be exactly 32 bytes" ); let signature_str = String::from_utf8_lossy(signature_bytes) .trim_end_matches('\0') .to_string(); assert_eq!( signature_str, "HWP Document File", "Signature content must be 'HWP Document File'" ); // Validate version format (0xMMnnPPrr) // MM should be 5 for HWP 5.0 let major = (fileheader.version >> 24) & 0xFF; let minor = (fileheader.version >> 16) & 0xFF; let patch = (fileheader.version >> 8) & 0xFF; let revision = fileheader.version & 0xFF; assert_eq!(major, 5, "Major version should be 5 for HWP 5.0"); assert!( minor <= 0xFF && patch <= 0xFF && revision <= 0xFF, "Version components should be valid (0-255)" ); // Validate document_flags (check bit flags) // Bit 0: 압축 여부 let is_compressed = (fileheader.document_flags & 0x01) != 0; assert_eq!( is_compressed, fileheader.is_compressed(), "is_compressed() should match bit 0" ); // Bit 1: 암호 설정 여부 let is_encrypted = (fileheader.document_flags & 0x02) != 0; assert_eq!( is_encrypted, fileheader.is_encrypted(), "is_encrypted() should match bit 1" ); // Validate EncryptVersion (should be 0-4 according to spec) assert!( fileheader.encrypt_version <= 4, "EncryptVersion should be 0-4, got {}", fileheader.encrypt_version ); // Validate KOGL Country (should be 0, 6, or 15 according to spec) // Valid values: 0 (Not set), 6 (KOR), 15 (US) assert!( fileheader.kogl_country == 0 || fileheader.kogl_country == 6 || fileheader.kogl_country == 15, "KOGL Country should be 0, 6, or 15, got {}", fileheader.kogl_country ); // Validate reserved field (should be exactly 207 bytes) assert_eq!( fileheader.reserved.len(), 207, "Reserved field must be exactly 207 bytes, got {}", fileheader.reserved.len() ); // Validate total structure size let total_size = 32 // signature + 4 // version + 4 // document_flags + 4 // license_flags + 4 // encrypt_version + 1 // kogl_country + 207; // reserved assert_eq!(total_size, 256, "Total FileHeader size should be 256 bytes"); } Err(e) => { panic!("Should be able to read FileHeader stream: {}", e); } } } Err(_) => { // Skip test if file not available } } } #[test] fn test_fileheader_is_compressed() { let mut data = vec![0u8; 256]; let signature = b"HWP Document File\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"; data[0..signature.len()].copy_from_slice(signature); data[32..36].copy_from_slice(&0x05000300u32.to_le_bytes()); // Test with compression flag set data[36..40].copy_from_slice(&0x01u32.to_le_bytes()); let fileheader = FileHeader::parse(&data).unwrap(); assert!(fileheader.is_compressed()); // Test without compression flag data[36..40].copy_from_slice(&0x00u32.to_le_bytes()); let fileheader = FileHeader::parse(&data).unwrap(); assert!(!fileheader.is_compressed()); } #[test] fn test_fileheader_is_encrypted() { let mut data = vec![0u8; 256]; let signature = b"HWP Document File\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"; data[0..signature.len()].copy_from_slice(signature); data[32..36].copy_from_slice(&0x05000300u32.to_le_bytes()); // Test with encryption flag set data[36..40].copy_from_slice(&0x02u32.to_le_bytes()); let fileheader = FileHeader::parse(&data).unwrap(); assert!(fileheader.is_encrypted()); // Test without encryption flag data[36..40].copy_from_slice(&0x00u32.to_le_bytes()); let fileheader = FileHeader::parse(&data).unwrap(); assert!(!fileheader.is_encrypted()); }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/tests/common.rs

crates/hwp-core/tests/common.rs

/// 공통 테스트 헬퍼 함수들 /// Common test helper functions use std::path::PathBuf; /// Helper function to find test HWP files directory pub fn find_fixtures_dir() -> Option<PathBuf> { let manifest_dir = std::env::var("CARGO_MANIFEST_DIR") .ok() .map(PathBuf::from) .unwrap_or_else(|| std::path::PathBuf::from(".")); let fixtures_path = manifest_dir.join("tests").join("fixtures"); if fixtures_path.exists() && fixtures_path.is_dir() { return Some(fixtures_path); } // Fallback for backward compatibility let possible_paths = ["tests/fixtures", "./tests/fixtures"]; for path_str in &possible_paths { let path = std::path::Path::new(path_str); if path.exists() && path.is_dir() { return Some(path.to_path_buf()); } } None } /// Helper function to find test HWP file (for snapshot tests, uses noori.hwp) pub fn find_test_file() -> Option<String> { if let Some(dir) = find_fixtures_dir() { let file_path = dir.join("noori.hwp"); if file_path.exists() { return Some(file_path.to_string_lossy().to_string()); } } None } /// Helper function to find headerfooter.hwp file pub fn find_headerfooter_file() -> Option<String> { if let Some(dir) = find_fixtures_dir() { let file_path = dir.join("headerfooter.hwp"); if file_path.exists() { return Some(file_path.to_string_lossy().to_string()); } } None } /// Helper function to get all HWP files in fixtures directory pub fn find_all_hwp_files() -> Vec<String> { if let Some(dir) = find_fixtures_dir() { let mut files = Vec::new(); if let Ok(entries) = std::fs::read_dir(&dir) { for entry in entries.flatten() { let path = entry.path(); if path.is_file() && path.extension().and_then(|s| s.to_str()) == Some("hwp") { if let Some(path_str) = path.to_str() { files.push(path_str.to_string()); } } } } files.sort(); return files; } Vec::new() } /// Helper function to find a specific HWP file in fixtures directory pub fn find_fixture_file(filename: &str) -> Option<String> { if let Some(dir) = find_fixtures_dir() { let file_path = dir.join(filename); if file_path.exists() { return Some(file_path.to_string_lossy().to_string()); } } None }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/tests/cfb_tests.rs

crates/hwp-core/tests/cfb_tests.rs

/// CFB 파서 테스트 /// CFB parser tests mod common; use hwp_core::*; use std::fs; #[test] fn test_cfb_parse_basic() { // Test with actual HWP file from fixtures directory use crate::common::find_fixture_file; if let Some(path) = find_fixture_file("noori.hwp") { if let Ok(data) = fs::read(path) { let result = CfbParser::parse(&data); assert!( result.is_ok(), "CFB parsing should succeed for valid HWP file" ); } } } #[test] fn test_cfb_read_fileheader() { // Test reading FileHeader stream from CFB use crate::common::find_fixture_file; if let Some(path) = find_fixture_file("noori.hwp") { if let Ok(data) = fs::read(path) { let mut cfb = CfbParser::parse(&data).expect("Should parse CFB"); let result = CfbParser::read_stream(&mut cfb, "FileHeader"); assert!(result.is_ok(), "Should be able to read FileHeader stream"); let fileheader = result.unwrap(); assert!(!fileheader.is_empty(), "FileHeader should not be empty"); assert_eq!(fileheader.len(), 256, "FileHeader should be 256 bytes"); } } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/tests/decompress_tests.rs

crates/hwp-core/tests/decompress_tests.rs

/// 압축 해제 테스트 /// Decompression tests use hwp_core::*; #[test] fn test_decompress_zlib_basic() { // Create a simple test: compress "hello" using zlib format and then decompress it use flate2::write::ZlibEncoder; use flate2::Compression; use std::io::Write; let original = b"hello world"; let mut encoder = ZlibEncoder::new(Vec::new(), Compression::default()); encoder.write_all(original).unwrap(); let compressed = encoder.finish().unwrap(); let decompressed = decompress_zlib(&compressed).expect("Should decompress"); assert_eq!( decompressed, original, "Decompressed data should match original" ); } #[test] fn test_decompress_zlib_empty() { // Empty data should still work (though it might error, which is fine) let result = decompress_zlib(b""); // Either Ok with empty vec or Err is acceptable if let Ok(data) = result { assert!(data.is_empty() || !data.is_empty()); } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/crates/hwp-core/tests/snapshot_tests.rs

crates/hwp-core/tests/snapshot_tests.rs

/// 스냅샷 테스트 /// Snapshot tests mod common; use common::*; use hwp_core::*; use hwp_core::document::ParagraphRecord; use insta::{assert_snapshot, with_settings}; // insta가 tests/snapshots 디렉토리를 사용하도록 설정하는 헬퍼 매크로 macro_rules! assert_snapshot_with_path { ($name:expr, $value:expr) => { let manifest_dir = env!("CARGO_MANIFEST_DIR"); let snapshots_dir = std::path::Path::new(manifest_dir) .join("tests") .join("snapshots"); with_settings!({ snapshot_path => snapshots_dir }, { assert_snapshot!($name, $value); }); }; } #[test] fn test_full_document_json_snapshot() { let file_path = match find_test_file() { Some(path) => path, None => return, // Skip test if file not available }; // 파일명에서 스냅샷 이름 추출 / Extract snapshot name from filename let file_name = std::path::Path::new(&file_path) .file_stem() .and_then(|n| n.to_str()) .unwrap_or("unknown"); let snapshot_name = file_name.replace(['-', '.'], "_"); let snapshot_name_json = format!("{}_json", snapshot_name); if let Ok(data) = std::fs::read(&file_path) { let parser = HwpParser::new(); let result = parser.parse(&data); if let Err(e) = &result { eprintln!("Parse error: {:?}", e); } assert!(result.is_ok(), "Should parse HWP document"); let document = result.unwrap(); // Verify BodyText is parsed correctly // BodyText가 올바르게 파싱되었는지 검증 assert!( !document.body_text.sections.is_empty(), "BodyText should have at least one section" ); assert!( document.body_text.sections[0].index == 0, "First section should have index 0" ); assert!( !document.body_text.sections[0].paragraphs.is_empty(), "First section should have at least one paragraph" ); // Convert to JSON // serde_json already outputs unicode characters as-is (not escaped) // Only control characters are escaped according to JSON standard let json = serde_json::to_string_pretty(&document).expect("Should serialize document to JSON"); assert_snapshot_with_path!(snapshot_name_json.as_str(), json); // 실제 JSON 파일로도 저장 / Also save as actual JSON file let manifest_dir = env!("CARGO_MANIFEST_DIR"); let snapshots_dir = std::path::Path::new(manifest_dir) .join("tests") .join("snapshots"); std::fs::create_dir_all(&snapshots_dir).unwrap_or(()); let json_file = snapshots_dir.join(format!("{}.json", file_name)); std::fs::write(&json_file, &json).unwrap_or_else(|e| { eprintln!("Failed to write JSON file: {}", e); }); } } #[test] fn test_all_fixtures_json_snapshots() { // 모든 fixtures 파일에 대해 JSON 스냅샷 생성 / Generate JSON snapshots for all fixtures files let hwp_files = find_all_hwp_files(); if hwp_files.is_empty() { println!("No HWP files found in fixtures directory"); return; } let parser = HwpParser::new(); let manifest_dir = env!("CARGO_MANIFEST_DIR"); let snapshots_dir = std::path::Path::new(manifest_dir) .join("tests") .join("snapshots"); for file_path in &hwp_files { let file_name = std::path::Path::new(file_path) .file_stem() .and_then(|n| n.to_str()) .unwrap_or("unknown"); // 파일명을 스냅샷 이름으로 사용 (특수 문자 제거) / Use filename as snapshot name (remove special chars) let snapshot_name = file_name.replace(['-', '.'], "_"); let snapshot_name_json = format!("{}_json", snapshot_name); match std::fs::read(file_path) { Ok(data) => { match parser.parse(&data) { Ok(document) => { // Convert to JSON let json = serde_json::to_string_pretty(&document) .expect("Should serialize document to JSON"); // 스냅샷 생성 / Create snapshot assert_snapshot_with_path!(snapshot_name_json.as_str(), json); // 실제 JSON 파일로도 저장 / Also save as actual JSON file let json_file = snapshots_dir.join(format!("{}.json", file_name)); std::fs::create_dir_all(&snapshots_dir).unwrap_or(()); std::fs::write(&json_file, &json).unwrap_or_else(|e| { eprintln!("Failed to write JSON file {}: {}", json_file.display(), e); }); } Err(e) => { eprintln!("Skipping {} due to parse error: {}", file_name, e); } } } Err(e) => { eprintln!("Failed to read {}: {}", file_name, e); } } } } #[test] fn test_debug_record_levels() { let file_path = match find_test_file() { Some(path) => path, None => return, }; if let Ok(data) = std::fs::read(&file_path) { let mut cfb = CfbParser::parse(&data).expect("Should parse CFB"); let fileheader = FileHeader::parse( &CfbParser::read_stream(&mut cfb, "FileHeader").expect("Should read FileHeader"), ) .expect("Should parse FileHeader"); let section_data = CfbParser::read_nested_stream(&mut cfb, "BodyText", "Section0") .expect("Should read Section0"); let decompressed = if fileheader.is_compressed() { hwp_core::decompress_deflate(&section_data).expect("Should decompress section data") } else { section_data }; let mut offset = 0; let mut record_count = 0; let mut table_records = Vec::new(); let mut list_header_records = Vec::new(); while offset < decompressed.len() { let remaining_data = &decompressed[offset..]; match RecordHeader::parse(remaining_data) { Ok((header, header_size)) => { record_count += 1; let tag_id = header.tag_id; let level = header.level; let size = header.size as usize; if tag_id == 0x43 { table_records.push((record_count, level, offset)); println!( "Record {}: TABLE (0x43) at offset {}, level {}", record_count, offset, level ); } if tag_id == 0x44 { list_header_records.push((record_count, level, offset)); println!( "Record {}: LIST_HEADER (0x44) at offset {}, level {}", record_count, offset, level ); } offset += header_size + size; } Err(_) => break, } } println!("\n=== Summary ==="); println!("Total records: {}", record_count); println!("TABLE records: {}", table_records.len()); println!("LIST_HEADER records: {}", list_header_records.len()); for (table_idx, table_level, table_offset) in &table_records { println!( "\nTABLE at record {} (offset {}, level {}):", table_idx, table_offset, table_level ); for (list_idx, list_level, list_offset) in &list_header_records { if *list_offset > *table_offset && *list_offset < *table_offset + 1000 { println!( " -> LIST_HEADER at record {} (offset {}, level {})", list_idx, list_offset, list_level ); } } } } } #[test] fn test_debug_list_header_children() { let file_path = match find_test_file() { Some(path) => path, None => return, }; if let Ok(data) = std::fs::read(&file_path) { let parser = HwpParser::new(); let result = parser.parse(&data); if let Err(e) = &result { eprintln!("Parse error: {:?}", e); } assert!(result.is_ok(), "Should parse HWP document"); let _document = result.unwrap(); use hwp_core::decompress::decompress_deflate; use hwp_core::document::bodytext::record_tree::RecordTreeNode; use hwp_core::CfbParser; use hwp_core::FileHeader; let mut cfb = CfbParser::parse(&data).expect("Should parse CFB"); let fileheader = FileHeader::parse( &CfbParser::read_stream(&mut cfb, "FileHeader").expect("Should read FileHeader"), ) .expect("Should parse FileHeader"); let section_data = CfbParser::read_nested_stream(&mut cfb, "BodyText", "Section0") .expect("Should read Section0"); let decompressed = if fileheader.is_compressed() { decompress_deflate(&section_data).expect("Should decompress section data") } else { section_data }; let tree = RecordTreeNode::parse_tree(&decompressed).expect("Should parse tree"); // LIST_HEADER 찾기 및 자식 확인 / Find LIST_HEADER and check children fn find_list_headers(node: &RecordTreeNode, depth: usize) { if node.tag_id() == 0x44 { // HWPTAG_LIST_HEADER println!( "{}LIST_HEADER (level {}): {} children", " ".repeat(depth), node.level(), node.children().len() ); for (i, child) in node.children().iter().enumerate() { println!( "{} Child {}: tag_id={}, level={}", " ".repeat(depth), i, child.tag_id(), child.level() ); if child.tag_id() == 0x32 { // HWPTAG_PARA_HEADER println!("{} -> PARA_HEADER found!", " ".repeat(depth)); } } } for child in node.children() { find_list_headers(child, depth + 1); } } println!("=== LIST_HEADER Children Debug ==="); find_list_headers(&tree, 0); } } #[test] fn test_document_markdown_snapshot() { let file_path = match find_test_file() { Some(path) => path, None => return, // Skip test if file not available }; // 파일명에서 스냅샷 이름 추출 / Extract snapshot name from filename let file_name = std::path::Path::new(&file_path) .file_stem() .and_then(|n| n.to_str()) .unwrap_or("unknown"); let snapshot_name = file_name.replace(['-', '.'], "_"); let snapshot_name_md = format!("{}_markdown", snapshot_name); if let Ok(data) = std::fs::read(&file_path) { let parser = HwpParser::new(); let result = parser.parse(&data); if let Err(e) = &result { eprintln!("Parse error: {:?}", e); } assert!(result.is_ok(), "Should parse HWP document"); let document = result.unwrap(); // Convert to markdown with image files (not base64) // 이미지를 파일로 저장하고 파일 경로를 사용 / Save images as files and use file paths let manifest_dir = env!("CARGO_MANIFEST_DIR"); let snapshots_dir = std::path::Path::new(manifest_dir) .join("tests") .join("snapshots"); let images_dir = snapshots_dir.join("images").join(file_name); std::fs::create_dir_all(&images_dir).unwrap_or(()); let options = hwp_core::viewer::markdown::MarkdownOptions { image_output_dir: images_dir.to_str().map(|s| s.to_string()), use_html: Some(true), include_version: Some(true), include_page_info: Some(true), }; let markdown = document.to_markdown(&options); assert_snapshot_with_path!(snapshot_name_md.as_str(), markdown); // 실제 Markdown 파일로도 저장 / Also save as actual Markdown file let md_file = snapshots_dir.join(format!("{}.md", file_name)); std::fs::write(&md_file, &markdown).unwrap_or_else(|e| { eprintln!("Failed to write Markdown file: {}", e); }); } } #[test] fn test_headerfooter_markdown() { // headerfooter.hwp 파일에 대해 Markdown 스냅샷 생성 / Generate Markdown snapshot for headerfooter.hwp let file_path = match find_headerfooter_file() { Some(path) => path, None => { eprintln!("headerfooter.hwp not found, skipping test"); return; } }; let parser = HwpParser::new(); let manifest_dir = env!("CARGO_MANIFEST_DIR"); let snapshots_dir = std::path::Path::new(manifest_dir) .join("tests") .join("snapshots"); let file_name = std::path::Path::new(&file_path) .file_stem() .and_then(|n| n.to_str()) .unwrap_or("unknown"); let snapshot_name = file_name.replace(['-', '.'], "_"); let snapshot_name_md = format!("{}_markdown", snapshot_name); match std::fs::read(&file_path) { Ok(data) => { match parser.parse(&data) { Ok(document) => { // Convert to markdown with image files (not base64) // 이미지를 파일로 저장하고 파일 경로를 사용 / Save images as files and use file paths let images_dir = snapshots_dir.join("images").join(file_name); std::fs::create_dir_all(&images_dir).unwrap_or(()); let options = hwp_core::viewer::markdown::MarkdownOptions { image_output_dir: images_dir.to_str().map(|s| s.to_string()), use_html: Some(true), include_version: Some(true), include_page_info: Some(true), }; let markdown = document.to_markdown(&options); // 스냅샷 생성 / Create snapshot assert_snapshot_with_path!(snapshot_name_md.as_str(), markdown); // 실제 Markdown 파일로도 저장 / Also save as actual Markdown file let md_file = snapshots_dir.join(format!("{}.md", file_name)); std::fs::create_dir_all(&snapshots_dir).unwrap_or(()); std::fs::write(&md_file, &markdown).unwrap_or_else(|e| { eprintln!("Failed to write Markdown file {}: {}", md_file.display(), e); }); } Err(e) => { eprintln!("Failed to parse {}: {:?}", file_path, e); } } } Err(e) => { eprintln!("Failed to read {}: {}", file_path, e); } } } #[test] fn test_all_fixtures_markdown_snapshots() { // 모든 fixtures 파일에 대해 Markdown 스냅샷 생성 / Generate Markdown snapshots for all fixtures files let hwp_files = find_all_hwp_files(); if hwp_files.is_empty() { println!("No HWP files found in fixtures directory"); return; } let parser = HwpParser::new(); let manifest_dir = env!("CARGO_MANIFEST_DIR"); let snapshots_dir = std::path::Path::new(manifest_dir) .join("tests") .join("snapshots"); for file_path in &hwp_files { let file_name = std::path::Path::new(file_path) .file_stem() .and_then(|n| n.to_str()) .unwrap_or("unknown"); // 파일명을 스냅샷 이름으로 사용 (특수 문자 제거) / Use filename as snapshot name (remove special chars) let snapshot_name = file_name.replace(['-', '.'], "_"); let snapshot_name_md = format!("{}_markdown", snapshot_name); match std::fs::read(file_path) { Ok(data) => { match parser.parse(&data) { Ok(document) => { // Convert to markdown with image files (not base64) // 이미지를 파일로 저장하고 파일 경로를 사용 / Save images as files and use file paths let images_dir = snapshots_dir.join("images").join(file_name); std::fs::create_dir_all(&images_dir).unwrap_or(()); let options = hwp_core::viewer::markdown::MarkdownOptions { image_output_dir: images_dir.to_str().map(|s| s.to_string()), use_html: Some(true), include_version: Some(true), include_page_info: Some(true), }; let markdown = document.to_markdown(&options); // 스냅샷 생성 / Create snapshot assert_snapshot_with_path!(snapshot_name_md.as_str(), markdown); // 실제 Markdown 파일로도 저장 / Also save as actual Markdown file let md_file = snapshots_dir.join(format!("{}.md", file_name)); std::fs::create_dir_all(&snapshots_dir).unwrap_or(()); std::fs::write(&md_file, &markdown).unwrap_or_else(|e| { eprintln!("Failed to write Markdown file {}: {}", md_file.display(), e); }); } Err(e) => { eprintln!("Skipping {} due to parse error: {}", file_name, e); } } } Err(e) => { eprintln!("Failed to read {}: {}", file_name, e); } } } } #[test] fn test_document_html_snapshot() { let file_path = match find_fixture_file("linespacing.hwp") { Some(path) => path, None => return, // Skip test if file not available }; // 파일명에서 스냅샷 이름 추출 / Extract snapshot name from filename let file_name = std::path::Path::new(&file_path) .file_stem() .and_then(|n| n.to_str()) .unwrap_or("unknown"); let snapshot_name = file_name.replace(['-', '.'], "_"); let snapshot_name_html = format!("{}_html", snapshot_name); if let Ok(data) = std::fs::read(&file_path) { let parser = HwpParser::new(); let result = parser.parse(&data); if let Err(e) = &result { eprintln!("Parse error: {:?}", e); } assert!(result.is_ok(), "Should parse HWP document"); let document = result.unwrap(); // Convert to HTML with image files (not base64) // 이미지를 파일로 저장하고 파일 경로를 사용 / Save images as files and use file paths let manifest_dir = env!("CARGO_MANIFEST_DIR"); let snapshots_dir = std::path::Path::new(manifest_dir) .join("tests") .join("snapshots"); let images_dir = snapshots_dir.join("images").join(file_name); std::fs::create_dir_all(&images_dir).unwrap_or(()); let options = hwp_core::viewer::HtmlOptions { image_output_dir: images_dir.to_str().map(|s| s.to_string()), html_output_dir: snapshots_dir.to_str().map(|s| s.to_string()), include_version: Some(true), include_page_info: Some(true), css_class_prefix: "ohah-hwpjs-".to_string(), }; let html = document.to_html(&options); assert_snapshot_with_path!(snapshot_name_html.as_str(), html); // 실제 HTML 파일로도 저장 / Also save as actual HTML file let html_file = snapshots_dir.join(format!("{}.html", file_name)); std::fs::write(&html_file, &html).unwrap_or_else(|e| { eprintln!("Failed to write HTML file: {}", e); }); } } #[test] fn test_headerfooter_html() { // headerfooter.hwp 파일에 대해 HTML 스냅샷 생성 / Generate HTML snapshot for headerfooter.hwp let file_path = match find_headerfooter_file() { Some(path) => path, None => { eprintln!("headerfooter.hwp not found, skipping test"); return; } }; let parser = HwpParser::new(); let manifest_dir = env!("CARGO_MANIFEST_DIR"); let snapshots_dir = std::path::Path::new(manifest_dir) .join("tests") .join("snapshots"); let file_name = std::path::Path::new(&file_path) .file_stem() .and_then(|n| n.to_str()) .unwrap_or("unknown"); let snapshot_name = file_name.replace(['-', '.'], "_"); let snapshot_name_html = format!("{}_html", snapshot_name); match std::fs::read(&file_path) { Ok(data) => { match parser.parse(&data) { Ok(document) => { // Convert to HTML with image files (not base64) // 이미지를 파일로 저장하고 파일 경로를 사용 / Save images as files and use file paths let images_dir = snapshots_dir.join("images").join(file_name); std::fs::create_dir_all(&images_dir).unwrap_or(()); let options = hwp_core::viewer::html::HtmlOptions { image_output_dir: images_dir.to_str().map(|s| s.to_string()), html_output_dir: snapshots_dir.to_str().map(|s| s.to_string()), include_version: Some(true), include_page_info: Some(true), css_class_prefix: "ohah-hwpjs-".to_string(), }; let html = document.to_html(&options); // 스냅샷 생성 / Create snapshot assert_snapshot_with_path!(snapshot_name_html.as_str(), html); // 실제 HTML 파일로도 저장 / Also save as actual HTML file let html_file = snapshots_dir.join(format!("{}.html", file_name)); std::fs::create_dir_all(&snapshots_dir).unwrap_or(()); std::fs::write(&html_file, &html).unwrap_or_else(|e| { eprintln!("Failed to write HTML file {}: {}", html_file.display(), e); }); } Err(e) => { eprintln!("Failed to parse {}: {:?}", file_path, e); } } } Err(e) => { eprintln!("Failed to read {}: {}", file_path, e); } } } #[test] fn test_all_fixtures_html_snapshots() { // 모든 fixtures 파일에 대해 HTML 스냅샷 생성 / Generate HTML snapshots for all fixtures files let hwp_files = find_all_hwp_files(); if hwp_files.is_empty() { println!("No HWP files found in fixtures directory"); return; } let parser = HwpParser::new(); let manifest_dir = env!("CARGO_MANIFEST_DIR"); let snapshots_dir = std::path::Path::new(manifest_dir) .join("tests") .join("snapshots"); for file_path in &hwp_files { let file_name = std::path::Path::new(file_path) .file_stem() .and_then(|n| n.to_str()) .unwrap_or("unknown"); // 파일명을 스냅샷 이름으로 사용 (특수 문자 제거) / Use filename as snapshot name (remove special chars) let snapshot_name = file_name.replace(['-', '.'], "_"); let snapshot_name_html = format!("{}_html", snapshot_name); match std::fs::read(file_path) { Ok(data) => { match parser.parse(&data) { Ok(document) => { // Convert to HTML with image files (not base64) // 이미지를 파일로 저장하고 파일 경로를 사용 / Save images as files and use file paths let images_dir = snapshots_dir.join("images").join(file_name); std::fs::create_dir_all(&images_dir).unwrap_or(()); let options = hwp_core::viewer::html::HtmlOptions { image_output_dir: images_dir.to_str().map(|s| s.to_string()), html_output_dir: snapshots_dir.to_str().map(|s| s.to_string()), include_version: Some(true), include_page_info: Some(true), css_class_prefix: String::new(), // table.html과 일치하도록 빈 문자열 사용 }; if file_name == "table" { eprintln!("DEBUG: Processing table.hwp file"); } let html = document.to_html(&options); // 스냅샷 생성 / Create snapshot assert_snapshot_with_path!(snapshot_name_html.as_str(), html); // 실제 HTML 파일로도 저장 / Also save as actual HTML file let html_file = snapshots_dir.join(format!("{}.html", file_name)); std::fs::create_dir_all(&snapshots_dir).unwrap_or(()); std::fs::write(&html_file, &html).unwrap_or_else(|e| { eprintln!("Failed to write HTML file {}: {}", html_file.display(), e); }); } Err(e) => { eprintln!("Skipping {} due to parse error: {}", file_name, e); } } } Err(e) => { eprintln!("Failed to read {}: {}", file_name, e); } } } } #[test] fn test_table2_html_snapshot() { // table2.hwp 파일만 테스트 / Test only table2.hwp file let manifest_dir = env!("CARGO_MANIFEST_DIR"); let fixtures_dir = std::path::Path::new(manifest_dir) .join("tests") .join("fixtures"); let file_path = fixtures_dir.join("table2.hwp"); if !file_path.exists() { eprintln!("table2.hwp not found, skipping test"); return; } let parser = HwpParser::new(); let snapshots_dir = std::path::Path::new(manifest_dir) .join("tests") .join("snapshots"); let file_name = "table2"; let snapshot_name_html = "table2_html"; match std::fs::read(&file_path) { Ok(data) => { match parser.parse(&data) { Ok(document) => { // Convert to HTML with image files (not base64) // 이미지를 파일로 저장하고 파일 경로를 사용 / Save images as files and use file paths let images_dir = snapshots_dir.join("images").join(file_name); std::fs::create_dir_all(&images_dir).unwrap_or(()); let options = hwp_core::viewer::html::HtmlOptions { image_output_dir: images_dir.to_str().map(|s| s.to_string()), html_output_dir: snapshots_dir.to_str().map(|s| s.to_string()), include_version: Some(true), include_page_info: Some(true), css_class_prefix: String::new(), // table.html과 일치하도록 빈 문자열 사용 }; eprintln!("DEBUG: Processing table2.hwp file"); let html = document.to_html(&options); // 스냅샷 생성 / Create snapshot assert_snapshot_with_path!(snapshot_name_html, html); // 실제 HTML 파일로도 저장 / Also save as actual HTML file let html_file = snapshots_dir.join(format!("{}.html", file_name)); std::fs::create_dir_all(&snapshots_dir).unwrap_or(()); std::fs::write(&html_file, &html).unwrap_or_else(|e| { eprintln!("Failed to write HTML file {}: {}", html_file.display(), e); }); } Err(e) => { eprintln!("Parse error for table2.hwp: {}", e); panic!("Failed to parse table2.hwp: {}", e); } } } Err(e) => { eprintln!("Failed to read table2.hwp: {}", e); panic!("Failed to read table2.hwp: {}", e); } } } #[test] fn test_parse_all_fixtures() { // 모든 fixtures 파일을 파싱하여 에러가 없는지 확인 / Parse all fixtures files to check for errors let hwp_files = find_all_hwp_files(); if hwp_files.is_empty() { println!("No HWP files found in fixtures directory"); return; } let parser = HwpParser::new(); let mut success_count = 0; let mut error_count = 0; let mut error_files: Vec<(String, String, String)> = Vec::new(); // (file, version, error) for file_path in &hwp_files { match std::fs::read(file_path) { Ok(data) => { // FileHeader 버전 확인 / Check FileHeader version use hwp_core::CfbParser; use hwp_core::FileHeader; let version_str = match CfbParser::parse(&data) { Ok(mut cfb) => match CfbParser::read_stream(&mut cfb, "FileHeader") { Ok(fileheader_data) => match FileHeader::parse(&fileheader_data) { Ok(fh) => { let major = (fh.version >> 24) & 0xFF; let minor = (fh.version >> 16) & 0xFF; let patch = (fh.version >> 8) & 0xFF; let revision = fh.version & 0xFF; format!("{}.{}.{}.{}", major, minor, patch, revision) } Err(_) => "unknown".to_string(), }, Err(_) => "unknown".to_string(), }, Err(_) => "unknown".to_string(), }; match parser.parse(&data) { Ok(_document) => { success_count += 1; } Err(e) => { error_count += 1; let file_name = std::path::Path::new(file_path) .file_name() .and_then(|n| n.to_str()) .unwrap_or(file_path); error_files.push((file_name.to_string(), version_str, e.to_string())); eprintln!("Failed to parse {}: {}", file_path, e); } } } Err(e) => { error_count += 1; eprintln!("Failed to read {}: {}", file_path, e); } } } println!("\n=== Summary ===",); println!( "Parsed {} files successfully, {} errors", success_count, error_count ); // 에러 유형별 통계 / Statistics by error type let mut object_common_errors: Vec<(String, String, String)> = Vec::new(); let mut other_errors: Vec<(String, String, String)> = Vec::new(); for (file, version, error) in &error_files { if error.contains("Object common properties must be at least 42 bytes") { object_common_errors.push((file.clone(), version.clone(), error.clone())); } else { other_errors.push((file.clone(), version.clone(), error.clone())); } } if !object_common_errors.is_empty() { println!( "\n=== Object common properties 40-byte errors ({} files) ===", object_common_errors.len() ); for (file, version, error) in &object_common_errors { println!(" {} (version: {}): {}", file, version, error); } } if !other_errors.is_empty() { println!("\n=== Other errors ({} files) ===", other_errors.len()); for (file, version, error) in &other_errors { println!(" {} (version: {}): {}", file, version, error); } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

true

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/packages/hwpjs/build.rs

packages/hwpjs/build.rs

fn main() { napi_build::setup(); }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/packages/hwpjs/src/lib.rs

packages/hwpjs/src/lib.rs

#![deny(clippy::all)] use base64::{engine::general_purpose::STANDARD, Engine as _}; use hwp_core::HwpParser; use napi::bindgen_prelude::Buffer; use napi_derive::napi; /// Convert HWP file to JSON /// /// # Arguments /// * `data` - Byte array containing HWP file data (Buffer or Uint8Array) /// /// # Returns /// Parsed HWP document as JSON string #[napi] pub fn to_json(data: Buffer) -> Result<String, napi::Error> { let parser = HwpParser::new(); let data_vec: Vec<u8> = data.into(); let document = parser.parse(&data_vec).map_err(napi::Error::from_reason)?; // Convert to JSON serde_json::to_string(&document) .map_err(|e| napi::Error::from_reason(format!("Failed to serialize to JSON: {}", e))) } /// Image format option for markdown conversion /// 마크다운 변환 시 이미지 형식 옵션 #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum ImageFormat { /// Base64 data URI embedded directly in markdown /// 마크다운에 base64 데이터 URI를 직접 포함 Base64, /// Image data as separate blob array /// 이미지를 별도 blob 배열로 반환 Blob, } /// Markdown conversion options #[napi(object)] pub struct ToMarkdownOptions { /// Optional directory path to save images as files. If None, images are embedded as base64 data URIs. /// 이미지를 파일로 저장할 디렉토리 경로 (선택). None이면 base64 데이터 URI로 임베드됩니다. pub image_output_dir: Option<String>, /// Image format: 'base64' to embed base64 data URI directly in markdown, 'blob' to return as separate ImageData array (default: 'blob') /// 이미지 형식: 'base64'는 마크다운에 base64 데이터 URI를 직접 포함, 'blob'은 별도 ImageData 배열로 반환 (기본값: 'blob') pub image: Option<String>, /// Whether to use HTML tags (if Some(true), use <br> tags in areas where line breaks are not possible, such as tables) /// HTML 태그 사용 여부 (Some(true)인 경우 테이블 등 개행 불가 영역에 <br> 태그 사용) pub use_html: Option<bool>, /// Whether to include version information /// 버전 정보 포함 여부 pub include_version: Option<bool>, /// Whether to include page information /// 페이지 정보 포함 여부 pub include_page_info: Option<bool>, } /// Image data structure #[napi(object)] pub struct ImageData { /// Image ID (e.g., "image-0") /// 이미지 ID (예: "image-0") pub id: String, /// Image data as Uint8Array /// 이미지 데이터 (Uint8Array) pub data: Buffer, /// Image format (e.g., "jpg", "png", "bmp") /// 이미지 형식 (예: "jpg", "png", "bmp") pub format: String, } /// Markdown conversion result #[napi(object)] pub struct ToMarkdownResult { /// Markdown string with image references (e.g., "![이미지](image-0)") /// 이미지 참조가 포함된 마크다운 문자열 (예: "![이미지](image-0)") pub markdown: String, /// Extracted image data /// 추출된 이미지 데이터 pub images: Vec<ImageData>, } /// Convert HWP file to Markdown format /// /// # Arguments /// * `data` - Byte array containing HWP file data (Buffer or Uint8Array) /// * `options` - Optional markdown conversion options /// /// # Returns /// ToMarkdownResult containing markdown string and image data #[napi] pub fn to_markdown( data: Buffer, options: Option<ToMarkdownOptions>, ) -> Result<ToMarkdownResult, napi::Error> { let parser = HwpParser::new(); let data_vec: Vec<u8> = data.into(); let document = parser.parse(&data_vec).map_err(napi::Error::from_reason)?; // Determine image format option (default: 'blob') let image_format = options .as_ref() .and_then(|o| o.image.as_ref()) .map(|s| s.to_lowercase()) .map(|s| match s.as_str() { "base64" => ImageFormat::Base64, "blob" => ImageFormat::Blob, _ => ImageFormat::Blob, // Default to blob for invalid values }) .unwrap_or(ImageFormat::Blob); // Build markdown options let markdown_options = hwp_core::viewer::markdown::MarkdownOptions { image_output_dir: None, // Force base64 mode for internal processing use_html: options.as_ref().and_then(|o| o.use_html), include_version: options.as_ref().and_then(|o| o.include_version), include_page_info: options.as_ref().and_then(|o| o.include_page_info), }; // Convert to markdown with base64 images let mut markdown = document.to_markdown(&markdown_options); // Extract images from BinData let mut images = Vec::new(); match image_format { ImageFormat::Base64 => { // For base64 format, we need to ensure all image placeholders are replaced with base64 URIs // to_markdown should already generate base64 URIs, but we'll make sure by replacing any placeholders for (index, bin_item) in document.bin_data.items.iter().enumerate() { let mime_type = get_mime_type_from_bindata_id(&document, bin_item.index); let base64_data_uri = format!("data:{};base64,{}", mime_type, bin_item.data); let image_id = format!("image-{}", index); // Replace any placeholder with base64 URI let placeholder_pattern = format!("![이미지]({})", image_id); if markdown.contains(&placeholder_pattern) { markdown = markdown.replace( &placeholder_pattern, &format!("![이미지]({})", base64_data_uri), ); } // Also check if there's already a base64 URI and ensure it's correct // (This handles the case where to_markdown already generated base64) // No need to do anything if base64 is already there } // Don't add to images array for base64 format } ImageFormat::Blob => { // Extract all images and replace base64 URIs with placeholders for (index, bin_item) in document.bin_data.items.iter().enumerate() { // Get extension and mime type from bin_data_records let extension = get_extension_from_bindata_id(&document, bin_item.index); let mime_type = get_mime_type_from_bindata_id(&document, bin_item.index); let base64_data_uri = format!("data:{};base64,{}", mime_type, bin_item.data); let image_id = format!("image-{}", index); // Decode base64 data for blob format let image_data = STANDARD.decode(&bin_item.data).map_err(|e| { napi::Error::from_reason(format!("Failed to decode base64 image data: {}", e)) })?; images.push(ImageData { id: image_id.clone(), data: Buffer::from(image_data), format: extension, }); // Replace base64 data URIs in markdown with placeholders // Pattern: ![이미지](data:image/...;base64,...) let pattern = format!("![이미지]({})", base64_data_uri); let replacement = format!("![이미지]({})", image_id); markdown = markdown.replace(&pattern, &replacement); // Also handle cases where the pattern might be split across lines or have different formatting let pattern2 = format!( "![이미지]({})", base64_data_uri.replace("(", "\$").replace(")", "\$") ); markdown = markdown.replace(&pattern2, &replacement); } } } Ok(ToMarkdownResult { markdown, images }) } /// Get file extension from BinData ID fn get_extension_from_bindata_id( document: &hwp_core::HwpDocument, bindata_id: hwp_core::WORD, ) -> String { for record in &document.doc_info.bin_data { if let hwp_core::BinDataRecord::Embedding { embedding, .. } = record { if embedding.binary_data_id == bindata_id { return embedding.extension.clone(); } } } "jpg".to_string() } /// Get MIME type from BinData ID fn get_mime_type_from_bindata_id( document: &hwp_core::HwpDocument, bindata_id: hwp_core::WORD, ) -> String { for record in &document.doc_info.bin_data { if let hwp_core::BinDataRecord::Embedding { embedding, .. } = record { if embedding.binary_data_id == bindata_id { return match embedding.extension.to_lowercase().as_str() { "jpg" | "jpeg" => "image/jpeg", "png" => "image/png", "gif" => "image/gif", "bmp" => "image/bmp", _ => "image/jpeg", } .to_string(); } } } "image/jpeg".to_string() } /// HTML conversion options #[napi(object)] pub struct ToHtmlOptions { /// Optional directory path to save images as files. If None, images are embedded as base64 data URIs. /// 이미지를 파일로 저장할 디렉토리 경로 (선택). None이면 base64 데이터 URI로 임베드됩니다. pub image_output_dir: Option<String>, /// Directory path where HTML file is saved (used for calculating relative image paths) /// HTML 파일이 저장되는 디렉토리 경로 (이미지 상대 경로 계산에 사용) pub html_output_dir: Option<String>, /// Whether to include version information /// 버전 정보 포함 여부 pub include_version: Option<bool>, /// Whether to include page information /// 페이지 정보 포함 여부 pub include_page_info: Option<bool>, /// CSS class prefix (default: "" - noori.html style) /// CSS 클래스 접두사 (기본값: "" - noori.html 스타일) pub css_class_prefix: Option<String>, } /// Convert HWP file to HTML format /// /// # Arguments /// * `data` - Byte array containing HWP file data (Buffer or Uint8Array) /// * `options` - Optional HTML conversion options /// /// # Returns /// HTML string representation of the document #[napi] pub fn to_html(data: Buffer, options: Option<ToHtmlOptions>) -> Result<String, napi::Error> { let parser = HwpParser::new(); let data_vec: Vec<u8> = data.into(); let document = parser.parse(&data_vec).map_err(napi::Error::from_reason)?; // Build HTML options let html_options = hwp_core::viewer::html::HtmlOptions { image_output_dir: options.as_ref().and_then(|o| o.image_output_dir.clone()), html_output_dir: options.as_ref().and_then(|o| o.html_output_dir.clone()), include_version: options.as_ref().and_then(|o| o.include_version), include_page_info: options.as_ref().and_then(|o| o.include_page_info), css_class_prefix: options .as_ref() .and_then(|o| o.css_class_prefix.clone()) .unwrap_or_default(), }; // Convert to HTML let html = document.to_html(&html_options); Ok(html) } /// Extract FileHeader from HWP file as JSON /// /// # Arguments /// * `data` - Byte array containing HWP file data (Buffer or Uint8Array) /// /// # Returns /// FileHeader as JSON string #[napi] pub fn file_header(data: Buffer) -> Result<String, napi::Error> { let parser = HwpParser::new(); let data_vec: Vec<u8> = data.into(); parser .parse_fileheader_json(&data_vec) .map_err(napi::Error::from_reason) }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/packages/hwpjs/crates/lib/build.rs

packages/hwpjs/crates/lib/build.rs

fn main() { craby_build::setup(); }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/packages/hwpjs/crates/lib/src/lib.rs

packages/hwpjs/crates/lib/src/lib.rs

#[rustfmt::skip] pub(crate) mod ffi; pub(crate) mod generated; pub(crate) mod hwpjs_impl;

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/packages/hwpjs/crates/lib/src/hwpjs_impl.rs

packages/hwpjs/crates/lib/src/hwpjs_impl.rs

use craby::{prelude::*, throw}; use crate::ffi::bridging::*; use crate::generated::*; use hwp_core::HwpParser; pub struct Hwpjs { ctx: Context, } #[craby_module] impl HwpjsSpec for Hwpjs { fn new(ctx: Context) -> Self { Self { ctx } } fn id(&self) -> usize { self.ctx.id } fn to_json(&mut self, data: Vec<u8>) -> String { let parser = HwpParser::new(); let document = parser.parse(&data).unwrap_or_else(|e| throw!("{}", e)); serde_json::to_string(&document) .unwrap_or_else(|e| throw!("Failed to serialize to JSON: {}", e)) } fn to_markdown(&mut self, data: Vec<u8>, options: ToMarkdownOptions) -> ToMarkdownResult { let parser = HwpParser::new(); let document = parser.parse(&data).unwrap_or_else(|e| throw!("{}", e)); // ToMarkdownOptions를 hwp_core::viewer::markdown::MarkdownOptions로 변환 let image_output_dir: Nullable<String> = options.image_output_dir.into(); let use_html = Some(options.use_html); let include_version = Some(options.include_version); let include_page_info = Some(options.include_page_info); let markdown_options = hwp_core::viewer::markdown::MarkdownOptions { image_output_dir: image_output_dir.into_value(), use_html, include_version, include_page_info, }; // 마크다운 변환 (이미지는 base64로 임베드) let markdown = document.to_markdown(&markdown_options); ToMarkdownResult { markdown } } fn file_header(&mut self, data: Vec<u8>) -> String { let parser = HwpParser::new(); parser .parse_fileheader_json(&data) .unwrap_or_else(|e| throw!("{}", e)) } }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false

ohah/hwpjs

https://github.com/ohah/hwpjs/blob/19df26a209c6e780b4c3b03d2ab628209e1ae311/packages/hwpjs/crates/lib/src/ffi.rs

packages/hwpjs/crates/lib/src/ffi.rs

// Auto generated by Craby. DO NOT EDIT. #[rustfmt::skip] use craby::prelude::*; use crate::generated::*; use crate::hwpjs_impl::*; use bridging::*; #[cxx::bridge(namespace = "craby::hwpjs::bridging")] pub mod bridging { #[derive(Clone)] struct NullableString { null: bool, val: String, } #[derive(Clone)] struct ToMarkdownResult { markdown: String, } #[derive(Clone)] struct ToMarkdownOptions { image_output_dir: NullableString, image: NullableString, use_html: bool, include_version: bool, include_page_info: bool, } extern "Rust" { type Hwpjs; #[cxx_name = "createHwpjs"] fn create_hwpjs(id: usize, data_path: &str) -> Box<Hwpjs>; #[cxx_name = "createVecFromSlice"] fn create_vec_from_slice(data: &[u8]) -> Vec<u8>; #[cxx_name = "fileHeader"] fn hwpjs_file_header(it_: &mut Hwpjs, data: Vec<u8>) -> Result<String>; #[cxx_name = "toJson"] fn hwpjs_to_json(it_: &mut Hwpjs, data: Vec<u8>) -> Result<String>; #[cxx_name = "toMarkdown"] fn hwpjs_to_markdown( it_: &mut Hwpjs, data: Vec<u8>, options: ToMarkdownOptions, ) -> Result<ToMarkdownResult>; } } fn create_hwpjs(id: usize, data_path: &str) -> Box<Hwpjs> { let ctx = Context::new(id, data_path); Box::new(Hwpjs::new(ctx)) } fn create_vec_from_slice(data: &[u8]) -> Vec<u8> { data.to_vec() } fn hwpjs_file_header(it_: &mut Hwpjs, data: Vec<u8>) -> Result<String, anyhow::Error> { craby::catch_panic!({ let ret = it_.file_header(data); ret }) } fn hwpjs_to_json(it_: &mut Hwpjs, data: Vec<u8>) -> Result<String, anyhow::Error> { craby::catch_panic!({ let ret = it_.to_json(data); ret }) } fn hwpjs_to_markdown( it_: &mut Hwpjs, data: Vec<u8>, options: ToMarkdownOptions, ) -> Result<ToMarkdownResult, anyhow::Error> { craby::catch_panic!({ let ret = it_.to_markdown(data, options); ret }) }

rust

MIT

19df26a209c6e780b4c3b03d2ab628209e1ae311

2026-01-04T20:24:59.575438Z

false