Skip to main content

sheetkit_core/
page_layout.rs

1//! Page layout settings for worksheets.
2//!
3//! Provides functions for configuring page margins, page setup (paper size,
4//! orientation, scaling), header/footer, print options, and page breaks.
5
6use sheetkit_xml::worksheet::{
7    Break, HeaderFooter, PageMargins, PageSetup, PrintOptions, RowBreaks, WorksheetXml,
8};
9
10use crate::error::Error;
11use crate::error::Result;
12use crate::utils::constants::{MAX_COLUMNS, MAX_ROWS};
13
14// -- Default margin values (inches, matching Excel defaults) --
15
16/// Default left margin in inches.
17pub const DEFAULT_MARGIN_LEFT: f64 = 0.7;
18/// Default right margin in inches.
19pub const DEFAULT_MARGIN_RIGHT: f64 = 0.7;
20/// Default top margin in inches.
21pub const DEFAULT_MARGIN_TOP: f64 = 0.75;
22/// Default bottom margin in inches.
23pub const DEFAULT_MARGIN_BOTTOM: f64 = 0.75;
24/// Default header margin in inches.
25pub const DEFAULT_MARGIN_HEADER: f64 = 0.3;
26/// Default footer margin in inches.
27pub const DEFAULT_MARGIN_FOOTER: f64 = 0.3;
28
29/// Page margin configuration in inches.
30#[derive(Debug, Clone)]
31pub struct PageMarginsConfig {
32    /// Left margin in inches.
33    pub left: f64,
34    /// Right margin in inches.
35    pub right: f64,
36    /// Top margin in inches.
37    pub top: f64,
38    /// Bottom margin in inches.
39    pub bottom: f64,
40    /// Header margin in inches.
41    pub header: f64,
42    /// Footer margin in inches.
43    pub footer: f64,
44}
45
46impl Default for PageMarginsConfig {
47    fn default() -> Self {
48        Self {
49            left: DEFAULT_MARGIN_LEFT,
50            right: DEFAULT_MARGIN_RIGHT,
51            top: DEFAULT_MARGIN_TOP,
52            bottom: DEFAULT_MARGIN_BOTTOM,
53            header: DEFAULT_MARGIN_HEADER,
54            footer: DEFAULT_MARGIN_FOOTER,
55        }
56    }
57}
58
59/// Page orientation.
60#[derive(Debug, Clone, Copy, PartialEq, Eq)]
61pub enum Orientation {
62    Portrait,
63    Landscape,
64}
65
66impl Orientation {
67    fn as_str(&self) -> &str {
68        match self {
69            Orientation::Portrait => "portrait",
70            Orientation::Landscape => "landscape",
71        }
72    }
73
74    fn from_str(s: &str) -> Option<Self> {
75        match s {
76            "portrait" => Some(Orientation::Portrait),
77            "landscape" => Some(Orientation::Landscape),
78            _ => None,
79        }
80    }
81}
82
83/// Standard paper sizes. The numeric values follow the OOXML specification.
84#[derive(Debug, Clone, Copy, PartialEq, Eq)]
85pub enum PaperSize {
86    Letter = 1,
87    Tabloid = 3,
88    Legal = 5,
89    A3 = 8,
90    A4 = 9,
91    A5 = 11,
92    B4 = 12,
93    B5 = 13,
94}
95
96impl PaperSize {
97    fn as_u32(self) -> u32 {
98        self as u32
99    }
100
101    /// Convert from a numeric paper size value.
102    pub fn from_u32(v: u32) -> Option<Self> {
103        match v {
104            1 => Some(PaperSize::Letter),
105            3 => Some(PaperSize::Tabloid),
106            5 => Some(PaperSize::Legal),
107            8 => Some(PaperSize::A3),
108            9 => Some(PaperSize::A4),
109            11 => Some(PaperSize::A5),
110            12 => Some(PaperSize::B4),
111            13 => Some(PaperSize::B5),
112            _ => None,
113        }
114    }
115}
116
117/// Set page margins on a worksheet.
118pub fn set_page_margins(ws: &mut WorksheetXml, margins: &PageMarginsConfig) -> Result<()> {
119    ws.page_margins = Some(PageMargins {
120        left: margins.left,
121        right: margins.right,
122        top: margins.top,
123        bottom: margins.bottom,
124        header: margins.header,
125        footer: margins.footer,
126    });
127    Ok(())
128}
129
130/// Get page margins from a worksheet, returning defaults if not set.
131pub fn get_page_margins(ws: &WorksheetXml) -> PageMarginsConfig {
132    match &ws.page_margins {
133        Some(pm) => PageMarginsConfig {
134            left: pm.left,
135            right: pm.right,
136            top: pm.top,
137            bottom: pm.bottom,
138            header: pm.header,
139            footer: pm.footer,
140        },
141        None => PageMarginsConfig::default(),
142    }
143}
144
145/// Set page setup options on a worksheet.
146///
147/// Only non-`None` parameters are applied; existing values for `None`
148/// parameters are preserved.
149pub fn set_page_setup(
150    ws: &mut WorksheetXml,
151    orientation: Option<Orientation>,
152    paper_size: Option<PaperSize>,
153    scale: Option<u32>,
154    fit_to_width: Option<u32>,
155    fit_to_height: Option<u32>,
156) -> Result<()> {
157    let setup = ws.page_setup.get_or_insert(PageSetup {
158        paper_size: None,
159        orientation: None,
160        scale: None,
161        fit_to_width: None,
162        fit_to_height: None,
163        first_page_number: None,
164        horizontal_dpi: None,
165        vertical_dpi: None,
166        r_id: None,
167    });
168
169    if let Some(o) = orientation {
170        setup.orientation = Some(o.as_str().to_string());
171    }
172    if let Some(ps) = paper_size {
173        setup.paper_size = Some(ps.as_u32());
174    }
175    if let Some(s) = scale {
176        setup.scale = Some(s);
177    }
178    if let Some(w) = fit_to_width {
179        setup.fit_to_width = Some(w);
180    }
181    if let Some(h) = fit_to_height {
182        setup.fit_to_height = Some(h);
183    }
184    Ok(())
185}
186
187/// Get the current orientation, if set.
188pub fn get_orientation(ws: &WorksheetXml) -> Option<Orientation> {
189    ws.page_setup
190        .as_ref()
191        .and_then(|ps| ps.orientation.as_deref())
192        .and_then(Orientation::from_str)
193}
194
195/// Get the current paper size, if set.
196pub fn get_paper_size(ws: &WorksheetXml) -> Option<PaperSize> {
197    ws.page_setup
198        .as_ref()
199        .and_then(|ps| ps.paper_size)
200        .and_then(PaperSize::from_u32)
201}
202
203/// Get the current scale, if set.
204pub fn get_scale(ws: &WorksheetXml) -> Option<u32> {
205    ws.page_setup.as_ref().and_then(|ps| ps.scale)
206}
207
208/// Get the current fit-to-width value, if set.
209pub fn get_fit_to_width(ws: &WorksheetXml) -> Option<u32> {
210    ws.page_setup.as_ref().and_then(|ps| ps.fit_to_width)
211}
212
213/// Get the current fit-to-height value, if set.
214pub fn get_fit_to_height(ws: &WorksheetXml) -> Option<u32> {
215    ws.page_setup.as_ref().and_then(|ps| ps.fit_to_height)
216}
217
218/// Set header and footer text for printing.
219///
220/// Both parameters are optional. Pass `None` to leave a field unchanged.
221/// Excel header/footer text uses special formatting codes (e.g., `&L`, `&C`,
222/// `&R` for left/center/right sections).
223pub fn set_header_footer(
224    ws: &mut WorksheetXml,
225    header: Option<&str>,
226    footer: Option<&str>,
227) -> Result<()> {
228    let hf = ws.header_footer.get_or_insert(HeaderFooter {
229        odd_header: None,
230        odd_footer: None,
231    });
232    if let Some(h) = header {
233        hf.odd_header = Some(h.to_string());
234    }
235    if let Some(f) = footer {
236        hf.odd_footer = Some(f.to_string());
237    }
238    Ok(())
239}
240
241/// Get the header and footer text.
242///
243/// Returns `(header, footer)` where each may be `None` if not set.
244pub fn get_header_footer(ws: &WorksheetXml) -> (Option<String>, Option<String>) {
245    match &ws.header_footer {
246        Some(hf) => (hf.odd_header.clone(), hf.odd_footer.clone()),
247        None => (None, None),
248    }
249}
250
251/// Set print options on a worksheet.
252///
253/// Only non-`None` parameters are applied; existing values for `None`
254/// parameters are preserved.
255pub fn set_print_options(
256    ws: &mut WorksheetXml,
257    grid_lines: Option<bool>,
258    headings: Option<bool>,
259    h_centered: Option<bool>,
260    v_centered: Option<bool>,
261) -> Result<()> {
262    let opts = ws.print_options.get_or_insert(PrintOptions {
263        grid_lines: None,
264        headings: None,
265        horizontal_centered: None,
266        vertical_centered: None,
267    });
268    if let Some(gl) = grid_lines {
269        opts.grid_lines = Some(gl);
270    }
271    if let Some(h) = headings {
272        opts.headings = Some(h);
273    }
274    if let Some(hc) = h_centered {
275        opts.horizontal_centered = Some(hc);
276    }
277    if let Some(vc) = v_centered {
278        opts.vertical_centered = Some(vc);
279    }
280    Ok(())
281}
282
283/// Get print options from a worksheet.
284///
285/// Returns `(grid_lines, headings, horizontal_centered, vertical_centered)`.
286pub fn get_print_options(
287    ws: &WorksheetXml,
288) -> (Option<bool>, Option<bool>, Option<bool>, Option<bool>) {
289    match &ws.print_options {
290        Some(po) => (
291            po.grid_lines,
292            po.headings,
293            po.horizontal_centered,
294            po.vertical_centered,
295        ),
296        None => (None, None, None, None),
297    }
298}
299
300/// Insert a horizontal page break before the given 1-based row number.
301///
302/// If a break already exists at this row, the call is a no-op.
303pub fn insert_page_break(ws: &mut WorksheetXml, row: u32) -> Result<()> {
304    let id = page_break_id(row, MAX_ROWS, Error::InvalidRowNumber)?;
305    let rb = ws.row_breaks.get_or_insert_with(|| RowBreaks {
306        count: None,
307        manual_break_count: None,
308        brk: vec![],
309    });
310
311    // Avoid duplicate breaks.
312    if rb.brk.iter().any(|b| b.id == id) {
313        return Ok(());
314    }
315
316    rb.brk.push(Break {
317        id,
318        max: Some(MAX_COLUMNS - 1),
319        man: Some(true),
320    });
321
322    // Sort breaks by row number.
323    rb.brk.sort_by_key(|b| b.id);
324
325    let count = rb.brk.len() as u32;
326    rb.count = Some(count);
327    rb.manual_break_count = Some(count);
328
329    Ok(())
330}
331
332/// Remove a horizontal page break at the given 1-based row number.
333///
334/// If no break exists at this row, the call is a no-op.
335pub fn remove_page_break(ws: &mut WorksheetXml, row: u32) -> Result<()> {
336    let id = page_break_id(row, MAX_ROWS, Error::InvalidRowNumber)?;
337    if let Some(rb) = &mut ws.row_breaks {
338        rb.brk.retain(|b| b.id != id);
339        if rb.brk.is_empty() {
340            ws.row_breaks = None;
341        } else {
342            let count = rb.brk.len() as u32;
343            rb.count = Some(count);
344            rb.manual_break_count = Some(count);
345        }
346    }
347    Ok(())
348}
349
350/// Get all row page break positions (1-based row numbers).
351///
352/// Parsed break IDs that do not map to a row in `1..=MAX_ROWS` (including
353/// `u32::MAX`) are skipped; the signature has no error channel and such a
354/// break cannot be addressed by `insert_page_break`/`remove_page_break`.
355pub fn get_page_breaks(ws: &WorksheetXml) -> Vec<u32> {
356    match &ws.row_breaks {
357        Some(rb) => break_coordinates(&rb.brk, MAX_ROWS),
358        None => vec![],
359    }
360}
361
362/// Insert a vertical page break before the given 1-based column number.
363///
364/// If a break already exists at this column, the call is a no-op.
365pub fn insert_column_page_break(ws: &mut WorksheetXml, column: u32) -> Result<()> {
366    let id = page_break_id(column, MAX_COLUMNS, Error::InvalidColumnNumber)?;
367    let cb = ws.col_breaks.get_or_insert_with(|| RowBreaks {
368        count: None,
369        manual_break_count: None,
370        brk: vec![],
371    });
372
373    if cb.brk.iter().any(|b| b.id == id) {
374        return Ok(());
375    }
376
377    cb.brk.push(Break {
378        id,
379        max: Some(MAX_ROWS - 1),
380        man: Some(true),
381    });
382    cb.brk.sort_by_key(|b| b.id);
383
384    let count = cb.brk.len() as u32;
385    cb.count = Some(count);
386    cb.manual_break_count = Some(count);
387    Ok(())
388}
389
390/// Remove a vertical page break at the given 1-based column number.
391///
392/// If no break exists at this column, the call is a no-op.
393pub fn remove_column_page_break(ws: &mut WorksheetXml, column: u32) -> Result<()> {
394    let id = page_break_id(column, MAX_COLUMNS, Error::InvalidColumnNumber)?;
395    if let Some(cb) = &mut ws.col_breaks {
396        cb.brk.retain(|b| b.id != id);
397        if cb.brk.is_empty() {
398            ws.col_breaks = None;
399        } else {
400            let count = cb.brk.len() as u32;
401            cb.count = Some(count);
402            cb.manual_break_count = Some(count);
403        }
404    }
405    Ok(())
406}
407
408/// Get all column page break positions (1-based column numbers).
409///
410/// Parsed break IDs that do not map to a column in `1..=MAX_COLUMNS` are
411/// skipped for the same reason as in [`get_page_breaks`].
412pub fn get_column_page_breaks(ws: &WorksheetXml) -> Vec<u32> {
413    match &ws.col_breaks {
414        Some(cb) => break_coordinates(&cb.brk, MAX_COLUMNS),
415        None => vec![],
416    }
417}
418
419/// Convert 0-based break IDs to 1-based coordinates within `1..=max_coordinate`.
420fn break_coordinates(breaks: &[Break], max_coordinate: u32) -> Vec<u32> {
421    breaks
422        .iter()
423        .filter_map(|b| b.id.checked_add(1))
424        .filter(|coordinate| *coordinate <= max_coordinate)
425        .collect()
426}
427
428fn page_break_id(
429    coordinate: u32,
430    max_coordinate: u32,
431    invalid: impl FnOnce(u32) -> Error,
432) -> Result<u32> {
433    if !(1..=max_coordinate).contains(&coordinate) {
434        return Err(invalid(coordinate));
435    }
436    Ok(coordinate - 1)
437}
438
439#[cfg(test)]
440mod tests {
441    use super::*;
442    use tempfile::TempDir;
443
444    use crate::workbook::Workbook;
445    use sheetkit_xml::worksheet::WorksheetXml;
446
447    // -- Page margins tests --
448
449    #[test]
450    fn test_set_get_page_margins() {
451        let mut ws = WorksheetXml::default();
452        let margins = PageMarginsConfig {
453            left: 1.0,
454            right: 1.0,
455            top: 1.5,
456            bottom: 1.5,
457            header: 0.5,
458            footer: 0.5,
459        };
460        set_page_margins(&mut ws, &margins).unwrap();
461
462        let result = get_page_margins(&ws);
463        assert_eq!(result.left, 1.0);
464        assert_eq!(result.right, 1.0);
465        assert_eq!(result.top, 1.5);
466        assert_eq!(result.bottom, 1.5);
467        assert_eq!(result.header, 0.5);
468        assert_eq!(result.footer, 0.5);
469    }
470
471    #[test]
472    fn test_default_page_margins() {
473        let ws = WorksheetXml::default();
474        let margins = get_page_margins(&ws);
475        assert_eq!(margins.left, DEFAULT_MARGIN_LEFT);
476        assert_eq!(margins.right, DEFAULT_MARGIN_RIGHT);
477        assert_eq!(margins.top, DEFAULT_MARGIN_TOP);
478        assert_eq!(margins.bottom, DEFAULT_MARGIN_BOTTOM);
479        assert_eq!(margins.header, DEFAULT_MARGIN_HEADER);
480        assert_eq!(margins.footer, DEFAULT_MARGIN_FOOTER);
481    }
482
483    #[test]
484    fn test_page_margins_default_values() {
485        let config = PageMarginsConfig::default();
486        assert_eq!(config.left, 0.7);
487        assert_eq!(config.right, 0.7);
488        assert_eq!(config.top, 0.75);
489        assert_eq!(config.bottom, 0.75);
490        assert_eq!(config.header, 0.3);
491        assert_eq!(config.footer, 0.3);
492    }
493
494    // -- Orientation tests --
495
496    #[test]
497    fn test_set_orientation_portrait() {
498        let mut ws = WorksheetXml::default();
499        set_page_setup(&mut ws, Some(Orientation::Portrait), None, None, None, None).unwrap();
500        assert_eq!(get_orientation(&ws), Some(Orientation::Portrait));
501    }
502
503    #[test]
504    fn test_set_orientation_landscape() {
505        let mut ws = WorksheetXml::default();
506        set_page_setup(
507            &mut ws,
508            Some(Orientation::Landscape),
509            None,
510            None,
511            None,
512            None,
513        )
514        .unwrap();
515        assert_eq!(get_orientation(&ws), Some(Orientation::Landscape));
516    }
517
518    #[test]
519    fn test_orientation_none_when_not_set() {
520        let ws = WorksheetXml::default();
521        assert_eq!(get_orientation(&ws), None);
522    }
523
524    // -- Paper size tests --
525
526    #[test]
527    fn test_set_paper_size_a4() {
528        let mut ws = WorksheetXml::default();
529        set_page_setup(&mut ws, None, Some(PaperSize::A4), None, None, None).unwrap();
530        assert_eq!(get_paper_size(&ws), Some(PaperSize::A4));
531    }
532
533    #[test]
534    fn test_set_paper_size_letter() {
535        let mut ws = WorksheetXml::default();
536        set_page_setup(&mut ws, None, Some(PaperSize::Letter), None, None, None).unwrap();
537        assert_eq!(get_paper_size(&ws), Some(PaperSize::Letter));
538    }
539
540    #[test]
541    fn test_paper_size_none_when_not_set() {
542        let ws = WorksheetXml::default();
543        assert_eq!(get_paper_size(&ws), None);
544    }
545
546    // -- Scale tests --
547
548    #[test]
549    fn test_set_scale() {
550        let mut ws = WorksheetXml::default();
551        set_page_setup(&mut ws, None, None, Some(75), None, None).unwrap();
552        assert_eq!(get_scale(&ws), Some(75));
553    }
554
555    #[test]
556    fn test_scale_none_when_not_set() {
557        let ws = WorksheetXml::default();
558        assert_eq!(get_scale(&ws), None);
559    }
560
561    // -- Fit to page tests --
562
563    #[test]
564    fn test_set_fit_to_page() {
565        let mut ws = WorksheetXml::default();
566        set_page_setup(&mut ws, None, None, None, Some(1), Some(2)).unwrap();
567        assert_eq!(get_fit_to_width(&ws), Some(1));
568        assert_eq!(get_fit_to_height(&ws), Some(2));
569    }
570
571    #[test]
572    fn test_fit_to_page_none_when_not_set() {
573        let ws = WorksheetXml::default();
574        assert_eq!(get_fit_to_width(&ws), None);
575        assert_eq!(get_fit_to_height(&ws), None);
576    }
577
578    // -- Multiple page setup options --
579
580    #[test]
581    fn test_set_page_setup_combined() {
582        let mut ws = WorksheetXml::default();
583        set_page_setup(
584            &mut ws,
585            Some(Orientation::Landscape),
586            Some(PaperSize::Legal),
587            Some(80),
588            None,
589            None,
590        )
591        .unwrap();
592
593        assert_eq!(get_orientation(&ws), Some(Orientation::Landscape));
594        assert_eq!(get_paper_size(&ws), Some(PaperSize::Legal));
595        assert_eq!(get_scale(&ws), Some(80));
596    }
597
598    #[test]
599    fn test_set_page_setup_preserves_existing() {
600        let mut ws = WorksheetXml::default();
601        set_page_setup(
602            &mut ws,
603            Some(Orientation::Landscape),
604            Some(PaperSize::A4),
605            None,
606            None,
607            None,
608        )
609        .unwrap();
610
611        // Second call should preserve orientation/paper size.
612        set_page_setup(&mut ws, None, None, Some(50), None, None).unwrap();
613
614        assert_eq!(get_orientation(&ws), Some(Orientation::Landscape));
615        assert_eq!(get_paper_size(&ws), Some(PaperSize::A4));
616        assert_eq!(get_scale(&ws), Some(50));
617    }
618
619    // -- Header footer tests --
620
621    #[test]
622    fn test_set_header_footer() {
623        let mut ws = WorksheetXml::default();
624        set_header_footer(&mut ws, Some("&CPage &P"), Some("&LFooter Left")).unwrap();
625
626        let (header, footer) = get_header_footer(&ws);
627        assert_eq!(header, Some("&CPage &P".to_string()));
628        assert_eq!(footer, Some("&LFooter Left".to_string()));
629    }
630
631    #[test]
632    fn test_set_header_only() {
633        let mut ws = WorksheetXml::default();
634        set_header_footer(&mut ws, Some("My Header"), None).unwrap();
635
636        let (header, footer) = get_header_footer(&ws);
637        assert_eq!(header, Some("My Header".to_string()));
638        assert_eq!(footer, None);
639    }
640
641    #[test]
642    fn test_set_footer_only() {
643        let mut ws = WorksheetXml::default();
644        set_header_footer(&mut ws, None, Some("My Footer")).unwrap();
645
646        let (header, footer) = get_header_footer(&ws);
647        assert_eq!(header, None);
648        assert_eq!(footer, Some("My Footer".to_string()));
649    }
650
651    #[test]
652    fn test_get_header_footer_none() {
653        let ws = WorksheetXml::default();
654        let (header, footer) = get_header_footer(&ws);
655        assert_eq!(header, None);
656        assert_eq!(footer, None);
657    }
658
659    #[test]
660    fn test_set_header_footer_preserves_existing() {
661        let mut ws = WorksheetXml::default();
662        set_header_footer(&mut ws, Some("Header1"), Some("Footer1")).unwrap();
663        // Update only header.
664        set_header_footer(&mut ws, Some("Header2"), None).unwrap();
665
666        let (header, footer) = get_header_footer(&ws);
667        assert_eq!(header, Some("Header2".to_string()));
668        assert_eq!(footer, Some("Footer1".to_string()));
669    }
670
671    // -- Print options tests --
672
673    #[test]
674    fn test_set_print_options() {
675        let mut ws = WorksheetXml::default();
676        set_print_options(&mut ws, Some(true), Some(true), Some(true), Some(false)).unwrap();
677
678        let (gl, hd, hc, vc) = get_print_options(&ws);
679        assert_eq!(gl, Some(true));
680        assert_eq!(hd, Some(true));
681        assert_eq!(hc, Some(true));
682        assert_eq!(vc, Some(false));
683    }
684
685    #[test]
686    fn test_get_print_options_none() {
687        let ws = WorksheetXml::default();
688        let (gl, hd, hc, vc) = get_print_options(&ws);
689        assert_eq!(gl, None);
690        assert_eq!(hd, None);
691        assert_eq!(hc, None);
692        assert_eq!(vc, None);
693    }
694
695    #[test]
696    fn test_set_print_options_partial() {
697        let mut ws = WorksheetXml::default();
698        set_print_options(&mut ws, Some(true), None, None, None).unwrap();
699
700        let (gl, hd, hc, vc) = get_print_options(&ws);
701        assert_eq!(gl, Some(true));
702        assert_eq!(hd, None);
703        assert_eq!(hc, None);
704        assert_eq!(vc, None);
705    }
706
707    #[test]
708    fn test_set_print_options_preserves_existing() {
709        let mut ws = WorksheetXml::default();
710        set_print_options(&mut ws, Some(true), Some(false), None, None).unwrap();
711        set_print_options(&mut ws, None, None, Some(true), None).unwrap();
712
713        let (gl, hd, hc, vc) = get_print_options(&ws);
714        assert_eq!(gl, Some(true));
715        assert_eq!(hd, Some(false));
716        assert_eq!(hc, Some(true));
717        assert_eq!(vc, None);
718    }
719
720    // -- Page break tests --
721
722    #[test]
723    fn test_insert_page_break() {
724        let mut ws = WorksheetXml::default();
725        insert_page_break(&mut ws, 10).unwrap();
726
727        let breaks = get_page_breaks(&ws);
728        assert_eq!(breaks, vec![10]);
729        assert_eq!(ws.row_breaks.as_ref().unwrap().brk[0].id, 9);
730    }
731
732    #[test]
733    fn test_page_breaks_convert_between_one_based_api_and_ooxml_ids() {
734        let mut ws = WorksheetXml::default();
735        for row in [1, 500_000, 1_048_576] {
736            insert_page_break(&mut ws, row).unwrap();
737        }
738
739        let row_breaks = ws.row_breaks.as_ref().unwrap();
740        assert_eq!(
741            row_breaks
742                .brk
743                .iter()
744                .map(|break_| break_.id)
745                .collect::<Vec<_>>(),
746            vec![0, 499_999, 1_048_575]
747        );
748        assert_eq!(get_page_breaks(&ws), vec![1, 500_000, 1_048_576]);
749
750        let xml = quick_xml::se::to_string(&ws).unwrap();
751        assert!(xml.contains(r#"<brk id="0""#));
752        assert!(xml.contains(r#"max="16383""#));
753        let reopened: WorksheetXml = quick_xml::de::from_str(&xml).unwrap();
754        assert_eq!(get_page_breaks(&reopened), vec![1, 500_000, 1_048_576]);
755    }
756
757    #[test]
758    fn test_column_page_breaks_convert_between_one_based_api_and_ooxml_ids() {
759        let mut ws = WorksheetXml::default();
760        for column in [1, 8_000, 16_384] {
761            insert_column_page_break(&mut ws, column).unwrap();
762        }
763
764        let column_breaks = ws.col_breaks.as_ref().unwrap();
765        assert_eq!(
766            column_breaks
767                .brk
768                .iter()
769                .map(|break_| break_.id)
770                .collect::<Vec<_>>(),
771            vec![0, 7_999, 16_383]
772        );
773        assert_eq!(get_column_page_breaks(&ws), vec![1, 8_000, 16_384]);
774
775        let xml = quick_xml::se::to_string(&ws).unwrap();
776        assert!(xml.contains(r#"<brk id="0""#));
777        assert!(xml.contains(r#"max="1048575""#));
778        let reopened: WorksheetXml = quick_xml::de::from_str(&xml).unwrap();
779        assert_eq!(get_column_page_breaks(&reopened), vec![1, 8_000, 16_384]);
780    }
781
782    #[test]
783    fn test_get_page_breaks_skips_parsed_out_of_grid_ids() {
784        let break_at = |id| Break {
785            id,
786            max: None,
787            man: Some(true),
788        };
789        let ws = WorksheetXml {
790            row_breaks: Some(RowBreaks {
791                count: Some(4),
792                manual_break_count: Some(4),
793                brk: vec![
794                    break_at(4),
795                    break_at(MAX_ROWS - 1),
796                    break_at(MAX_ROWS),
797                    break_at(u32::MAX),
798                ],
799            }),
800            col_breaks: Some(RowBreaks {
801                count: Some(4),
802                manual_break_count: Some(4),
803                brk: vec![
804                    break_at(2),
805                    break_at(MAX_COLUMNS - 1),
806                    break_at(MAX_COLUMNS),
807                    break_at(u32::MAX),
808                ],
809            }),
810            ..WorksheetXml::default()
811        };
812
813        assert_eq!(get_page_breaks(&ws), vec![5, MAX_ROWS]);
814        assert_eq!(get_column_page_breaks(&ws), vec![3, MAX_COLUMNS]);
815    }
816
817    #[test]
818    fn test_page_breaks_reject_zero_and_overflow_coordinates() {
819        let mut ws = WorksheetXml::default();
820        assert!(matches!(
821            insert_page_break(&mut ws, 0),
822            Err(crate::error::Error::InvalidRowNumber(0))
823        ));
824        assert!(matches!(
825            insert_page_break(&mut ws, 1_048_577),
826            Err(crate::error::Error::InvalidRowNumber(1_048_577))
827        ));
828        assert!(matches!(
829            insert_column_page_break(&mut ws, 0),
830            Err(crate::error::Error::InvalidColumnNumber(0))
831        ));
832        assert!(matches!(
833            insert_column_page_break(&mut ws, 16_385),
834            Err(crate::error::Error::InvalidColumnNumber(16_385))
835        ));
836    }
837
838    #[test]
839    fn test_page_breaks_survive_workbook_save_and_reopen() {
840        let dir = TempDir::new().unwrap();
841        let path = dir.path().join("page-breaks.xlsx");
842        let mut workbook = Workbook::new();
843        for row in [1, 500_000, 1_048_576] {
844            workbook.insert_page_break("Sheet1", row).unwrap();
845        }
846        workbook.save(&path).unwrap();
847
848        let reopened = Workbook::open(&path).unwrap();
849        assert_eq!(
850            reopened.get_page_breaks("Sheet1").unwrap(),
851            vec![1, 500_000, 1_048_576]
852        );
853    }
854
855    #[test]
856    fn test_insert_multiple_page_breaks() {
857        let mut ws = WorksheetXml::default();
858        insert_page_break(&mut ws, 20).unwrap();
859        insert_page_break(&mut ws, 10).unwrap();
860        insert_page_break(&mut ws, 30).unwrap();
861
862        let breaks = get_page_breaks(&ws);
863        assert_eq!(breaks, vec![10, 20, 30]);
864    }
865
866    #[test]
867    fn test_insert_duplicate_page_break_is_noop() {
868        let mut ws = WorksheetXml::default();
869        insert_page_break(&mut ws, 10).unwrap();
870        insert_page_break(&mut ws, 10).unwrap();
871
872        let breaks = get_page_breaks(&ws);
873        assert_eq!(breaks, vec![10]);
874    }
875
876    #[test]
877    fn test_remove_page_break() {
878        let mut ws = WorksheetXml::default();
879        insert_page_break(&mut ws, 10).unwrap();
880        insert_page_break(&mut ws, 20).unwrap();
881
882        remove_page_break(&mut ws, 10).unwrap();
883
884        let breaks = get_page_breaks(&ws);
885        assert_eq!(breaks, vec![20]);
886    }
887
888    #[test]
889    fn test_remove_last_page_break_clears_element() {
890        let mut ws = WorksheetXml::default();
891        insert_page_break(&mut ws, 10).unwrap();
892        remove_page_break(&mut ws, 10).unwrap();
893
894        assert!(ws.row_breaks.is_none());
895        assert!(get_page_breaks(&ws).is_empty());
896    }
897
898    #[test]
899    fn test_remove_nonexistent_page_break_is_noop() {
900        let mut ws = WorksheetXml::default();
901        insert_page_break(&mut ws, 10).unwrap();
902        remove_page_break(&mut ws, 99).unwrap();
903
904        let breaks = get_page_breaks(&ws);
905        assert_eq!(breaks, vec![10]);
906    }
907
908    #[test]
909    fn test_get_page_breaks_empty() {
910        let ws = WorksheetXml::default();
911        assert!(get_page_breaks(&ws).is_empty());
912    }
913
914    #[test]
915    fn test_page_break_max_value() {
916        let mut ws = WorksheetXml::default();
917        insert_page_break(&mut ws, 5).unwrap();
918
919        let rb = ws.row_breaks.as_ref().unwrap();
920        assert_eq!(rb.brk[0].max, Some(16383));
921        assert_eq!(rb.brk[0].man, Some(true));
922    }
923
924    #[test]
925    fn test_page_break_count_updated() {
926        let mut ws = WorksheetXml::default();
927        insert_page_break(&mut ws, 10).unwrap();
928        insert_page_break(&mut ws, 20).unwrap();
929        insert_page_break(&mut ws, 30).unwrap();
930
931        let rb = ws.row_breaks.as_ref().unwrap();
932        assert_eq!(rb.count, Some(3));
933        assert_eq!(rb.manual_break_count, Some(3));
934
935        remove_page_break(&mut ws, 20).unwrap();
936        let rb = ws.row_breaks.as_ref().unwrap();
937        assert_eq!(rb.count, Some(2));
938        assert_eq!(rb.manual_break_count, Some(2));
939    }
940
941    // -- Paper size enum tests --
942
943    #[test]
944    fn test_paper_size_values() {
945        assert_eq!(PaperSize::Letter.as_u32(), 1);
946        assert_eq!(PaperSize::Tabloid.as_u32(), 3);
947        assert_eq!(PaperSize::Legal.as_u32(), 5);
948        assert_eq!(PaperSize::A3.as_u32(), 8);
949        assert_eq!(PaperSize::A4.as_u32(), 9);
950        assert_eq!(PaperSize::A5.as_u32(), 11);
951        assert_eq!(PaperSize::B4.as_u32(), 12);
952        assert_eq!(PaperSize::B5.as_u32(), 13);
953    }
954
955    #[test]
956    fn test_paper_size_from_u32() {
957        assert_eq!(PaperSize::from_u32(1), Some(PaperSize::Letter));
958        assert_eq!(PaperSize::from_u32(9), Some(PaperSize::A4));
959        assert_eq!(PaperSize::from_u32(99), None);
960    }
961
962    // -- Orientation enum tests --
963
964    #[test]
965    fn test_orientation_as_str() {
966        assert_eq!(Orientation::Portrait.as_str(), "portrait");
967        assert_eq!(Orientation::Landscape.as_str(), "landscape");
968    }
969
970    #[test]
971    fn test_orientation_from_str() {
972        assert_eq!(
973            Orientation::from_str("portrait"),
974            Some(Orientation::Portrait)
975        );
976        assert_eq!(
977            Orientation::from_str("landscape"),
978            Some(Orientation::Landscape)
979        );
980        assert_eq!(Orientation::from_str("unknown"), None);
981    }
982}