1use 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
14pub const DEFAULT_MARGIN_LEFT: f64 = 0.7;
18pub const DEFAULT_MARGIN_RIGHT: f64 = 0.7;
20pub const DEFAULT_MARGIN_TOP: f64 = 0.75;
22pub const DEFAULT_MARGIN_BOTTOM: f64 = 0.75;
24pub const DEFAULT_MARGIN_HEADER: f64 = 0.3;
26pub const DEFAULT_MARGIN_FOOTER: f64 = 0.3;
28
29#[derive(Debug, Clone)]
31pub struct PageMarginsConfig {
32 pub left: f64,
34 pub right: f64,
36 pub top: f64,
38 pub bottom: f64,
40 pub header: f64,
42 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#[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#[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 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
117pub 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
130pub 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
145pub 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
187pub 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
195pub 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
203pub fn get_scale(ws: &WorksheetXml) -> Option<u32> {
205 ws.page_setup.as_ref().and_then(|ps| ps.scale)
206}
207
208pub fn get_fit_to_width(ws: &WorksheetXml) -> Option<u32> {
210 ws.page_setup.as_ref().and_then(|ps| ps.fit_to_width)
211}
212
213pub fn get_fit_to_height(ws: &WorksheetXml) -> Option<u32> {
215 ws.page_setup.as_ref().and_then(|ps| ps.fit_to_height)
216}
217
218pub 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
241pub 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
251pub 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
283pub 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
300pub 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 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 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
332pub 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
350pub 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
362pub 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
390pub 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
408pub 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
419fn 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 #[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 #[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 #[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 #[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 #[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 #[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 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 #[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 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 #[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 #[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 #[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 #[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}