1use crate::error::{Error, Result};
10use crate::utils::cell_ref::cell_name_to_coordinates;
11
12fn escape_xml(value: &str) -> String {
13 quick_xml::escape::escape(value).into_owned()
14}
15
16fn unescape_xml(value: &str) -> String {
17 quick_xml::escape::unescape(value)
18 .map(|value| value.into_owned())
19 .unwrap_or_else(|_| value.to_string())
20}
21
22#[derive(Debug, Clone, PartialEq)]
24pub enum FormControlType {
25 Button,
26 CheckBox,
27 OptionButton,
28 SpinButton,
29 ScrollBar,
30 GroupBox,
31 Label,
32}
33
34impl FormControlType {
35 pub fn object_type(&self) -> &str {
37 match self {
38 FormControlType::Button => "Button",
39 FormControlType::CheckBox => "Checkbox",
40 FormControlType::OptionButton => "Radio",
41 FormControlType::SpinButton => "Spin",
42 FormControlType::ScrollBar => "Scroll",
43 FormControlType::GroupBox => "GBox",
44 FormControlType::Label => "Label",
45 }
46 }
47
48 pub fn from_object_type(s: &str) -> Option<Self> {
50 match s {
51 "Button" => Some(FormControlType::Button),
52 "Checkbox" => Some(FormControlType::CheckBox),
53 "Radio" => Some(FormControlType::OptionButton),
54 "Spin" => Some(FormControlType::SpinButton),
55 "Scroll" => Some(FormControlType::ScrollBar),
56 "GBox" => Some(FormControlType::GroupBox),
57 "Label" => Some(FormControlType::Label),
58 _ => None,
59 }
60 }
61
62 pub fn parse(s: &str) -> Result<Self> {
64 match s.to_lowercase().as_str() {
65 "button" => Ok(FormControlType::Button),
66 "checkbox" | "check_box" | "check" => Ok(FormControlType::CheckBox),
67 "optionbutton" | "option_button" | "radio" | "radiobutton" | "radio_button" => {
68 Ok(FormControlType::OptionButton)
69 }
70 "spinbutton" | "spin_button" | "spin" | "spinner" => Ok(FormControlType::SpinButton),
71 "scrollbar" | "scroll_bar" | "scroll" => Ok(FormControlType::ScrollBar),
72 "groupbox" | "group_box" | "group" => Ok(FormControlType::GroupBox),
73 "label" => Ok(FormControlType::Label),
74 _ => Err(Error::InvalidArgument(format!(
75 "unknown form control type: {s}"
76 ))),
77 }
78 }
79}
80
81#[derive(Debug, Clone)]
83pub struct FormControlConfig {
84 pub control_type: FormControlType,
86 pub cell: String,
88 pub width: Option<f64>,
90 pub height: Option<f64>,
92 pub text: Option<String>,
94 pub macro_name: Option<String>,
96 pub cell_link: Option<String>,
98 pub checked: Option<bool>,
100 pub min_value: Option<u32>,
102 pub max_value: Option<u32>,
104 pub increment: Option<u32>,
106 pub page_increment: Option<u32>,
108 pub current_value: Option<u32>,
110 pub three_d: Option<bool>,
112}
113
114impl FormControlConfig {
115 pub fn button(cell: &str, text: &str) -> Self {
117 Self {
118 control_type: FormControlType::Button,
119 cell: cell.to_string(),
120 width: None,
121 height: None,
122 text: Some(text.to_string()),
123 macro_name: None,
124 cell_link: None,
125 checked: None,
126 min_value: None,
127 max_value: None,
128 increment: None,
129 page_increment: None,
130 current_value: None,
131 three_d: None,
132 }
133 }
134
135 pub fn checkbox(cell: &str, text: &str) -> Self {
137 Self {
138 control_type: FormControlType::CheckBox,
139 cell: cell.to_string(),
140 width: None,
141 height: None,
142 text: Some(text.to_string()),
143 macro_name: None,
144 cell_link: None,
145 checked: None,
146 min_value: None,
147 max_value: None,
148 increment: None,
149 page_increment: None,
150 current_value: None,
151 three_d: None,
152 }
153 }
154
155 pub fn spin_button(cell: &str, min: u32, max: u32) -> Self {
157 Self {
158 control_type: FormControlType::SpinButton,
159 cell: cell.to_string(),
160 width: None,
161 height: None,
162 text: None,
163 macro_name: None,
164 cell_link: None,
165 checked: None,
166 min_value: Some(min),
167 max_value: Some(max),
168 increment: Some(1),
169 page_increment: None,
170 current_value: Some(min),
171 three_d: None,
172 }
173 }
174
175 pub fn scroll_bar(cell: &str, min: u32, max: u32) -> Self {
177 Self {
178 control_type: FormControlType::ScrollBar,
179 cell: cell.to_string(),
180 width: None,
181 height: None,
182 text: None,
183 macro_name: None,
184 cell_link: None,
185 checked: None,
186 min_value: Some(min),
187 max_value: Some(max),
188 increment: Some(1),
189 page_increment: Some(10),
190 current_value: Some(min),
191 three_d: None,
192 }
193 }
194
195 pub fn validate(&self) -> Result<()> {
197 cell_name_to_coordinates(&self.cell)?;
198
199 for (field, value) in [
200 ("text", self.text.as_deref()),
201 ("macro_name", self.macro_name.as_deref()),
202 ] {
203 if value.is_some_and(|value| !value.chars().all(crate::utils::is_xml_char)) {
204 return Err(Error::InvalidArgument(format!(
205 "{field} contains a character that is not valid in XML 1.0"
206 )));
207 }
208 }
209
210 if let Some(ref cl) = self.cell_link {
211 cell_name_to_coordinates(cl)?;
212 }
213
214 let (default_width, default_height) = default_dimensions(&self.control_type);
215 build_control_anchor(
216 &self.cell,
217 self.width.unwrap_or(default_width),
218 self.height.unwrap_or(default_height),
219 )?;
220
221 if let (Some(min), Some(max)) = (self.min_value, self.max_value) {
222 if min > max {
223 return Err(Error::InvalidArgument(format!(
224 "min_value ({min}) must not exceed max_value ({max})"
225 )));
226 }
227 }
228
229 for (field, value) in [
230 ("min_value", self.min_value),
231 ("max_value", self.max_value),
232 ("increment", self.increment),
233 ("page_increment", self.page_increment),
234 ] {
235 if value.is_some_and(|value| value > 30_000) {
236 return Err(Error::InvalidArgument(format!(
237 "{field} must not exceed Excel's limit of 30000"
238 )));
239 }
240 }
241
242 if let Some(inc) = self.increment {
243 if inc == 0 {
244 return Err(Error::InvalidArgument(
245 "increment must be greater than 0".to_string(),
246 ));
247 }
248 }
249
250 if let Some(page_inc) = self.page_increment {
251 if page_inc == 0 {
252 return Err(Error::InvalidArgument(
253 "page_increment must be greater than 0".to_string(),
254 ));
255 }
256 }
257
258 Ok(())
259 }
260}
261
262#[derive(Debug, Clone, PartialEq)]
264pub struct FormControlInfo {
265 pub control_type: FormControlType,
266 pub cell: String,
267 pub text: Option<String>,
268 pub macro_name: Option<String>,
269 pub cell_link: Option<String>,
270 pub checked: Option<bool>,
271 pub current_value: Option<u32>,
272 pub min_value: Option<u32>,
273 pub max_value: Option<u32>,
274 pub increment: Option<u32>,
275 pub page_increment: Option<u32>,
276}
277
278pub(crate) fn build_control_property_xml(config: &FormControlConfig) -> String {
280 use std::fmt::Write;
281
282 let mut xml = String::from(
283 "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n<x14:formControlPr xmlns:x14=\"http://schemas.microsoft.com/office/spreadsheetml/2009/9/main\"",
284 );
285 let object_type = match config.control_type {
286 FormControlType::Button => "Button",
287 FormControlType::CheckBox => "CheckBox",
288 FormControlType::OptionButton => "Radio",
289 FormControlType::SpinButton => "Spin",
290 FormControlType::ScrollBar => "Scroll",
291 FormControlType::GroupBox => "GBox",
292 FormControlType::Label => "Label",
293 };
294 let _ = write!(xml, " objectType=\"{}\"", escape_xml(object_type));
295 if let Some(checked) = config.checked {
296 let checked = if checked { "Checked" } else { "Unchecked" };
297 let _ = write!(xml, " checked=\"{checked}\"");
298 }
299 if let Some(value) = config.current_value {
300 let _ = write!(xml, " val=\"{value}\"");
301 }
302 if let Some(value) = config.min_value {
303 let _ = write!(xml, " min=\"{value}\"");
304 }
305 if let Some(value) = config.max_value {
306 let _ = write!(xml, " max=\"{value}\"");
307 }
308 if let Some(value) = config.increment {
309 let _ = write!(xml, " inc=\"{value}\"");
310 }
311 if let Some(value) = config.page_increment {
312 let _ = write!(xml, " page=\"{value}\"");
313 }
314 if let Some(ref value) = config.cell_link {
315 let _ = write!(xml, " fmlaLink=\"{}\"", escape_xml(value));
316 }
317 if config.control_type == FormControlType::ScrollBar {
318 let (default_width, default_height) = default_dimensions(&config.control_type);
319 if config.width.unwrap_or(default_width) > config.height.unwrap_or(default_height) {
320 xml.push_str(" horiz=\"1\"");
321 }
322 }
323 if config.three_d == Some(false) {
324 xml.push_str(" noThreeD=\"1\"");
325 }
326 xml.push_str("/>");
327 xml
328}
329
330fn default_dimensions(ct: &FormControlType) -> (f64, f64) {
332 match ct {
333 FormControlType::Button => (72.0, 24.0),
334 FormControlType::CheckBox => (72.0, 18.0),
335 FormControlType::OptionButton => (72.0, 18.0),
336 FormControlType::SpinButton => (15.75, 30.0),
337 FormControlType::ScrollBar => (15.75, 60.0),
338 FormControlType::GroupBox => (120.0, 72.0),
339 FormControlType::Label => (72.0, 18.0),
340 }
341}
342
343const FORM_CONTROL_SHAPETYPE_ID: &str = "_x0000_t201";
345
346fn build_control_anchor(cell: &str, width_pt: f64, height_pt: f64) -> Result<String> {
351 if !width_pt.is_finite() || width_pt <= 0.0 {
352 return Err(Error::InvalidArgument(
353 "form control width must be finite and greater than 0".to_string(),
354 ));
355 }
356 if !height_pt.is_finite() || height_pt <= 0.0 {
357 return Err(Error::InvalidArgument(
358 "form control height must be finite and greater than 0".to_string(),
359 ));
360 }
361 let (col, row) = cell_name_to_coordinates(cell)?;
362 let col0 = col - 1;
363 let row0 = row - 1;
364
365 const COL_OFFSET_UNITS: f64 = 1024.0;
366 const ROW_OFFSET_UNITS: f64 = 256.0;
367 const STANDARD_COL_WIDTH_PT: f64 = 48.0;
368 const STANDARD_ROW_HEIGHT_PT: f64 = 15.0;
369 const START_COL_OFFSET: u32 = 15;
370 const START_ROW_OFFSET: u32 = 10;
371
372 let col_extent =
373 f64::from(START_COL_OFFSET) + width_pt / STANDARD_COL_WIDTH_PT * COL_OFFSET_UNITS;
374 let row_extent =
375 f64::from(START_ROW_OFFSET) + height_pt / STANDARD_ROW_HEIGHT_PT * ROW_OFFSET_UNITS;
376 if !col_extent.is_finite()
377 || !row_extent.is_finite()
378 || col_extent > 16_385.0 * COL_OFFSET_UNITS
379 || row_extent > 1_048_577.0 * ROW_OFFSET_UNITS
380 {
381 return Err(Error::InvalidArgument(
382 "form control dimensions exceed worksheet bounds".to_string(),
383 ));
384 }
385
386 let mut col_span = (col_extent / COL_OFFSET_UNITS).floor() as u32;
387 let mut col2_offset = (col_extent - f64::from(col_span) * COL_OFFSET_UNITS).round() as u32;
388 if col2_offset == COL_OFFSET_UNITS as u32 {
389 col_span += 1;
390 col2_offset = 0;
391 }
392
393 let mut row_span = (row_extent / ROW_OFFSET_UNITS).floor() as u32;
394 let mut row2_offset = (row_extent - f64::from(row_span) * ROW_OFFSET_UNITS).round() as u32;
395 if row2_offset == ROW_OFFSET_UNITS as u32 {
396 row_span += 1;
397 row2_offset = 0;
398 }
399
400 let col2 = col0
401 .checked_add(col_span)
402 .filter(|column| *column < 16_384)
403 .ok_or_else(|| Error::InvalidArgument("form control exceeds worksheet columns".into()))?;
404 let row2 = row0
405 .checked_add(row_span)
406 .filter(|row| *row < 1_048_576)
407 .ok_or_else(|| Error::InvalidArgument("form control exceeds worksheet rows".into()))?;
408
409 Ok(format!(
410 "{col0}, {START_COL_OFFSET}, {row0}, {START_ROW_OFFSET}, {col2}, {col2_offset}, {row2}, {row2_offset}"
411 ))
412}
413
414pub fn build_form_control_vml(controls: &[FormControlConfig], start_shape_id: usize) -> String {
420 use std::fmt::Write;
421
422 let mut shapes = String::new();
423 for (i, config) in controls.iter().enumerate() {
424 let shape_id = start_shape_id + i;
425 let (default_w, default_h) = default_dimensions(&config.control_type);
426 let width = config.width.unwrap_or(default_w);
427 let height = config.height.unwrap_or(default_h);
428
429 let anchor = match build_control_anchor(&config.cell, width, height) {
433 Ok(a) => a,
434 Err(_) => {
435 #[cfg(debug_assertions)]
436 eprintln!(
437 "warning: skipping form control with invalid cell ref '{}'",
438 config.cell
439 );
440 continue;
441 }
442 };
443
444 write_form_control_shape(&mut shapes, shape_id, i + 1, &anchor, config);
445 }
446
447 let mut doc = String::with_capacity(1024 + shapes.len());
448 doc.push_str("<xml xmlns:v=\"urn:schemas-microsoft-com:vml\"");
449 doc.push_str(" xmlns:o=\"urn:schemas-microsoft-com:office:office\"");
450 doc.push_str(" xmlns:x=\"urn:schemas-microsoft-com:office:excel\">\n");
451 doc.push_str(" <o:shapelayout v:ext=\"edit\">\n");
452 doc.push_str(" <o:idmap v:ext=\"edit\" data=\"1\"/>\n");
453 doc.push_str(" </o:shapelayout>\n");
454
455 let _ = write!(
457 doc,
458 " <v:shapetype id=\"{}\" coordsize=\"21600,21600\" o:spt=\"201\" \
459 path=\"m,l,21600r21600,l21600,xe\">\n\
460 \x20 <v:stroke joinstyle=\"miter\"/>\n\
461 \x20 <v:path gradientshapeok=\"t\" o:connecttype=\"rect\"/>\n\
462 </v:shapetype>\n",
463 FORM_CONTROL_SHAPETYPE_ID,
464 );
465
466 doc.push_str(&shapes);
467 doc.push_str("</xml>\n");
468 doc
469}
470
471fn write_form_control_shape(
473 out: &mut String,
474 shape_id: usize,
475 z_index: usize,
476 anchor: &str,
477 config: &FormControlConfig,
478) {
479 use std::fmt::Write;
480
481 let _ = write!(out, " <v:shape id=\"_x0000_s{shape_id}\"");
482 let _ = write!(out, " type=\"#{FORM_CONTROL_SHAPETYPE_ID}\"");
483 let _ = write!(
484 out,
485 " style=\"position:absolute;z-index:{z_index};visibility:visible\""
486 );
487
488 match config.control_type {
489 FormControlType::Button => {
490 out.push_str(" fillcolor=\"buttonFace\" o:insetmode=\"auto\">\n");
491 out.push_str(" <v:fill color2=\"buttonFace\" o:detectmouseclick=\"t\"/>\n");
492 out.push_str(" <o:lock v:ext=\"edit\" rotation=\"t\"/>\n");
493 if let Some(ref text) = config.text {
494 let text = escape_xml(text);
495 let _ = write!(
496 out,
497 " <v:textbox>\n\
498 \x20 <div style=\"text-align:center\">\
499 <font face=\"Calibri\" size=\"220\" color=\"#000000\">{text}</font>\
500 </div>\n\
501 \x20 </v:textbox>\n"
502 );
503 }
504 }
505 FormControlType::CheckBox | FormControlType::OptionButton => {
506 out.push_str(" fillcolor=\"window\" o:insetmode=\"auto\">\n");
507 out.push_str(" <v:fill color2=\"window\"/>\n");
508 if let Some(ref text) = config.text {
509 let text = escape_xml(text);
510 let _ = write!(
511 out,
512 " <v:textbox>\n\
513 \x20 <div>{text}</div>\n\
514 \x20 </v:textbox>\n"
515 );
516 }
517 }
518 FormControlType::SpinButton | FormControlType::ScrollBar => {
519 out.push_str(" fillcolor=\"buttonFace\" o:insetmode=\"auto\">\n");
520 out.push_str(" <v:fill color2=\"buttonFace\"/>\n");
521 }
522 FormControlType::GroupBox => {
523 out.push_str(" filled=\"f\" stroked=\"f\" o:insetmode=\"auto\">\n");
524 if let Some(ref text) = config.text {
525 let text = escape_xml(text);
526 let _ = write!(
527 out,
528 " <v:textbox>\n\
529 \x20 <div>{text}</div>\n\
530 \x20 </v:textbox>\n"
531 );
532 }
533 }
534 FormControlType::Label => {
535 out.push_str(" filled=\"f\" stroked=\"f\" o:insetmode=\"auto\">\n");
536 if let Some(ref text) = config.text {
537 let text = escape_xml(text);
538 let _ = write!(
539 out,
540 " <v:textbox>\n\
541 \x20 <div>{text}</div>\n\
542 \x20 </v:textbox>\n"
543 );
544 }
545 }
546 }
547
548 let object_type = config.control_type.object_type();
550 let _ = writeln!(out, " <x:ClientData ObjectType=\"{object_type}\">");
551 let _ = writeln!(out, " <x:Anchor>{anchor}</x:Anchor>");
552 out.push_str(" <x:PrintObject>False</x:PrintObject>\n");
553 out.push_str(" <x:AutoFill>False</x:AutoFill>\n");
554
555 if let Some(ref macro_name) = config.macro_name {
556 let macro_name = escape_xml(macro_name);
557 let _ = writeln!(out, " <x:FmlaMacro>{macro_name}</x:FmlaMacro>");
558 }
559
560 if let Some(ref cell_link) = config.cell_link {
561 let cell_link = escape_xml(cell_link);
562 let _ = writeln!(out, " <x:FmlaLink>{cell_link}</x:FmlaLink>");
563 }
564
565 if let Some(checked) = config.checked {
566 let val = if checked { 1 } else { 0 };
567 let _ = writeln!(out, " <x:Checked>{val}</x:Checked>");
568 }
569
570 if let Some(val) = config.current_value {
571 let _ = writeln!(out, " <x:Val>{val}</x:Val>");
572 }
573
574 if let Some(min) = config.min_value {
575 let _ = writeln!(out, " <x:Min>{min}</x:Min>");
576 }
577
578 if let Some(max) = config.max_value {
579 let _ = writeln!(out, " <x:Max>{max}</x:Max>");
580 }
581
582 if let Some(inc) = config.increment {
583 let _ = writeln!(out, " <x:Inc>{inc}</x:Inc>");
584 }
585
586 if let Some(page_inc) = config.page_increment {
587 let _ = writeln!(out, " <x:Page>{page_inc}</x:Page>");
588 }
589
590 let three_d = config.three_d.unwrap_or(true);
592 if !three_d {
593 out.push_str(" <x:NoThreeD/>\n");
594 }
595
596 out.push_str(" </x:ClientData>\n");
597 out.push_str(" </v:shape>\n");
598}
599
600pub fn parse_form_controls(vml_xml: &str) -> Vec<FormControlInfo> {
605 let mut controls = Vec::new();
606
607 let mut search_from = 0;
608 while let Some(shape_start) = vml_xml[search_from..].find("<v:shape ") {
609 let abs_start = search_from + shape_start;
610 let shape_end = match vml_xml[abs_start..].find("</v:shape>") {
611 Some(pos) => abs_start + pos + "</v:shape>".len(),
612 None => break,
613 };
614 let shape_xml = &vml_xml[abs_start..shape_end];
615
616 if let Some(info) = parse_single_control(shape_xml) {
618 controls.push(info);
619 }
620 search_from = shape_end;
621 }
622
623 controls
624}
625
626pub(crate) fn parse_form_control_configs(vml_xml: &str) -> Vec<FormControlConfig> {
628 let mut controls = Vec::new();
629 let mut search_from = 0;
630 while let Some(shape_start) = vml_xml[search_from..].find("<v:shape ") {
631 let abs_start = search_from + shape_start;
632 let shape_end = match vml_xml[abs_start..].find("</v:shape>") {
633 Some(pos) => abs_start + pos + "</v:shape>".len(),
634 None => break,
635 };
636 let shape_xml = &vml_xml[abs_start..shape_end];
637 if let Some(info) = parse_single_control(shape_xml) {
638 let mut config = info.to_config();
639 if let Some((width, height)) = extract_anchor_dimensions(shape_xml) {
640 config.width = Some(width);
641 config.height = Some(height);
642 }
643 if shape_xml.contains("<x:NoThreeD") {
644 config.three_d = Some(false);
645 }
646 controls.push(config);
647 }
648 search_from = shape_end;
649 }
650 controls
651}
652
653fn parse_single_control(shape_xml: &str) -> Option<FormControlInfo> {
655 let cd_start = shape_xml.find("<x:ClientData ")?;
657 let cd_end = shape_xml
658 .find("</x:ClientData>")
659 .map(|p| p + "</x:ClientData>".len())?;
660 let cd_xml = &shape_xml[cd_start..cd_end];
661
662 let obj_type = extract_attr(cd_xml, "ObjectType")?;
664 let control_type = FormControlType::from_object_type(&obj_type)?;
665
666 if obj_type == "Note" {
668 return None;
669 }
670
671 let cell = extract_anchor_cell(cd_xml).unwrap_or_default();
672 let text = extract_textbox_text(shape_xml);
673 let macro_name = extract_element(cd_xml, "x:FmlaMacro");
674 let cell_link = extract_element(cd_xml, "x:FmlaLink");
675 let checked = extract_element(cd_xml, "x:Checked").and_then(|v| match v.as_str() {
676 "1" => Some(true),
677 "0" => Some(false),
678 _ => None,
679 });
680 let current_value = extract_element(cd_xml, "x:Val").and_then(|v| v.parse().ok());
681 let min_value = extract_element(cd_xml, "x:Min").and_then(|v| v.parse().ok());
682 let max_value = extract_element(cd_xml, "x:Max").and_then(|v| v.parse().ok());
683 let increment = extract_element(cd_xml, "x:Inc").and_then(|v| v.parse().ok());
684 let page_increment = extract_element(cd_xml, "x:Page").and_then(|v| v.parse().ok());
685
686 Some(FormControlInfo {
687 control_type,
688 cell,
689 text,
690 macro_name,
691 cell_link,
692 checked,
693 current_value,
694 min_value,
695 max_value,
696 increment,
697 page_increment,
698 })
699}
700
701fn extract_attr(xml: &str, attr: &str) -> Option<String> {
703 let pattern = format!("{attr}=\"");
704 let start = xml.find(&pattern)?;
705 let val_start = start + pattern.len();
706 let end = xml[val_start..].find('"')?;
707 Some(unescape_xml(&xml[val_start..val_start + end]))
708}
709
710fn extract_element(xml: &str, tag: &str) -> Option<String> {
712 let open = format!("<{tag}>");
713 let close = format!("</{tag}>");
714 let start = xml.find(&open)?;
715 let content_start = start + open.len();
716 let end = xml[content_start..].find(&close)?;
717 let text = xml[content_start..content_start + end].trim().to_string();
718 if text.is_empty() {
719 None
720 } else {
721 Some(unescape_xml(&text))
722 }
723}
724
725fn extract_textbox_text(shape_xml: &str) -> Option<String> {
727 let tb_start = shape_xml.find("<v:textbox>")?;
728 let tb_end = shape_xml.find("</v:textbox>")?;
729 let tb_content = &shape_xml[tb_start + "<v:textbox>".len()..tb_end];
730
731 let mut text = String::new();
733 let mut in_tag = false;
734 for ch in tb_content.chars() {
735 match ch {
736 '<' => in_tag = true,
737 '>' => in_tag = false,
738 _ if !in_tag => text.push(ch),
739 _ => {}
740 }
741 }
742 let trimmed = text.trim().to_string();
743 if trimmed.is_empty() {
744 None
745 } else {
746 Some(unescape_xml(&trimmed))
747 }
748}
749
750fn extract_anchor_cell(cd_xml: &str) -> Option<String> {
755 let anchor_text = extract_element(cd_xml, "x:Anchor")?;
756 let parts: Vec<&str> = anchor_text.split(',').map(|s| s.trim()).collect();
757 if parts.len() < 4 {
758 return None;
759 }
760 let col0: u32 = parts[0].parse().ok()?;
761 let row0: u32 = parts[2].parse().ok()?;
762 crate::utils::cell_ref::coordinates_to_cell_name(col0 + 1, row0 + 1).ok()
763}
764
765fn extract_anchor_dimensions(shape_xml: &str) -> Option<(f64, f64)> {
766 let anchor_text = extract_element(shape_xml, "x:Anchor")?;
767 let parts = anchor_text
768 .split(',')
769 .map(str::trim)
770 .map(str::parse::<i64>)
771 .collect::<std::result::Result<Vec<_>, _>>()
772 .ok()?;
773 if parts.len() != 8 {
774 return None;
775 }
776 let width_units = (parts[4] - parts[0]) * 1024 + parts[5] - parts[1];
777 let height_units = (parts[6] - parts[2]) * 256 + parts[7] - parts[3];
778 if width_units <= 0 || height_units <= 0 {
779 return None;
780 }
781 Some((
782 width_units as f64 * 48.0 / 1024.0,
783 height_units as f64 * 15.0 / 256.0,
784 ))
785}
786
787pub fn merge_vml_controls(
793 existing_vml: &[u8],
794 controls: &[FormControlConfig],
795 start_shape_id: usize,
796) -> Vec<u8> {
797 let existing_str = String::from_utf8_lossy(existing_vml);
798
799 let mut shapes = String::new();
801 for (i, config) in controls.iter().enumerate() {
802 let shape_id = start_shape_id + i;
803 let (default_w, default_h) = default_dimensions(&config.control_type);
804 let width = config.width.unwrap_or(default_w);
805 let height = config.height.unwrap_or(default_h);
806
807 if let Ok(anchor) = build_control_anchor(&config.cell, width, height) {
808 write_form_control_shape(&mut shapes, shape_id, shape_id, &anchor, config);
809 }
810 }
811
812 let shapetype_exists = existing_str.contains(FORM_CONTROL_SHAPETYPE_ID);
814
815 let shapetype_xml = if !shapetype_exists {
816 format!(
817 " <v:shapetype id=\"{FORM_CONTROL_SHAPETYPE_ID}\" coordsize=\"21600,21600\" \
818 o:spt=\"201\" path=\"m,l,21600r21600,l21600,xe\">\n\
819 \x20 <v:stroke joinstyle=\"miter\"/>\n\
820 \x20 <v:path gradientshapeok=\"t\" o:connecttype=\"rect\"/>\n\
821 </v:shapetype>\n"
822 )
823 } else {
824 String::new()
825 };
826
827 if let Some(close_pos) = existing_str.rfind("</xml>") {
829 let mut result =
830 String::with_capacity(existing_str.len() + shapetype_xml.len() + shapes.len());
831 result.push_str(&existing_str[..close_pos]);
832 result.push_str(&shapetype_xml);
833 result.push_str(&shapes);
834 result.push_str("</xml>\n");
835 result.into_bytes()
836 } else {
837 build_form_control_vml(controls, start_shape_id).into_bytes()
839 }
840}
841
842impl FormControlInfo {
843 pub fn to_config(&self) -> FormControlConfig {
848 FormControlConfig {
849 control_type: self.control_type.clone(),
850 cell: self.cell.clone(),
851 width: None,
852 height: None,
853 text: self.text.clone(),
854 macro_name: self.macro_name.clone(),
855 cell_link: self.cell_link.clone(),
856 checked: self.checked,
857 min_value: self.min_value,
858 max_value: self.max_value,
859 increment: self.increment,
860 page_increment: self.page_increment,
861 current_value: self.current_value,
862 three_d: None,
863 }
864 }
865}
866
867pub fn count_vml_shapes(vml_bytes: &[u8]) -> usize {
869 let vml_str = String::from_utf8_lossy(vml_bytes);
870 vml_str.matches("<v:shape ").count()
871}
872
873pub(crate) fn next_vml_shape_id(vml_bytes: &[u8]) -> usize {
875 let text = String::from_utf8_lossy(vml_bytes);
876 let mut next = 1025usize;
877 let mut remaining = text.as_ref();
878 while let Some(index) = remaining.find("_x0000_s") {
879 let digits = &remaining[index + "_x0000_s".len()..];
880 let length = digits.bytes().take_while(u8::is_ascii_digit).count();
881 if let Ok(id) = digits[..length].parse::<usize>() {
882 next = next.max(id.saturating_add(1));
883 }
884 remaining = &digits[length..];
885 }
886 next
887}
888
889pub(crate) fn form_control_shape_ids(vml_bytes: &[u8]) -> Vec<usize> {
890 let text = String::from_utf8_lossy(vml_bytes);
891 let mut ids = Vec::new();
892 let mut search_from = 0;
893 while let Some(shape_start) = text[search_from..].find("<v:shape ") {
894 let abs_start = search_from + shape_start;
895 let Some(relative_end) = text[abs_start..].find("</v:shape>") else {
896 break;
897 };
898 let shape_end = abs_start + relative_end + "</v:shape>".len();
899 let shape = &text[abs_start..shape_end];
900 if parse_single_control(shape).is_some() {
901 if let Some(marker) = shape.find("id=\"_x0000_s") {
902 let digits = &shape[marker + "id=\"_x0000_s".len()..];
903 let length = digits.bytes().take_while(u8::is_ascii_digit).count();
904 if let Ok(id) = digits[..length].parse() {
905 ids.push(id);
906 }
907 }
908 }
909 search_from = shape_end;
910 }
911 ids
912}
913
914pub(crate) fn remove_form_control_shape(vml_bytes: &[u8], control_index: usize) -> Option<Vec<u8>> {
915 let text = String::from_utf8_lossy(vml_bytes);
916 let mut current_control = 0usize;
917 let mut search_from = 0;
918 while let Some(shape_start) = text[search_from..].find("<v:shape ") {
919 let abs_start = search_from + shape_start;
920 let Some(relative_end) = text[abs_start..].find("</v:shape>") else {
921 break;
922 };
923 let shape_end = abs_start + relative_end + "</v:shape>".len();
924 let shape = &text[abs_start..shape_end];
925 if parse_single_control(shape).is_some() {
926 if current_control == control_index {
927 let mut result = String::with_capacity(text.len() - (shape_end - abs_start));
928 result.push_str(&text[..abs_start]);
929 result.push_str(&text[shape_end..]);
930 return if parse_form_controls(&result).is_empty()
931 && !result.contains("ObjectType=\"Note\"")
932 && !result.contains("<v:shape ")
933 {
934 None
935 } else {
936 Some(result.into_bytes())
937 };
938 }
939 current_control += 1;
940 }
941 search_from = shape_end;
942 }
943 Some(vml_bytes.to_vec())
944}
945
946pub fn strip_form_control_shapes_from_vml(vml_bytes: &[u8]) -> Option<Vec<u8>> {
950 let vml_str = String::from_utf8_lossy(vml_bytes);
951
952 let mut keep_shapes = Vec::new();
954 let mut has_preserved_shapes = false;
955 let mut search_from = 0;
956
957 while let Some(shape_start) = vml_str[search_from..].find("<v:shape ") {
958 let abs_start = search_from + shape_start;
959 let shape_end = match vml_str[abs_start..].find("</v:shape>") {
960 Some(pos) => abs_start + pos + "</v:shape>".len(),
961 None => break,
962 };
963 let shape_xml = &vml_str[abs_start..shape_end];
964
965 if parse_single_control(shape_xml).is_none() {
966 keep_shapes.push((abs_start, shape_end));
967 has_preserved_shapes = true;
968 }
969 search_from = shape_end;
970 }
971
972 if !has_preserved_shapes {
973 return None;
974 }
975
976 let first_shape_pos = vml_str.find("<v:shape ").unwrap_or(vml_str.len());
979 let header = &vml_str[..first_shape_pos];
980
981 let mut result = String::with_capacity(vml_str.len());
982 result.push_str(header);
983
984 for (start, end) in &keep_shapes {
985 result.push_str(&vml_str[*start..*end]);
986 result.push('\n');
987 }
988
989 result.push_str("</xml>\n");
990 Some(result.into_bytes())
991}
992
993#[cfg(test)]
994#[allow(clippy::cloned_ref_to_slice_refs)]
995mod tests {
996 use super::*;
997
998 #[test]
999 fn test_form_control_type_parse() {
1000 assert_eq!(
1001 FormControlType::parse("button").unwrap(),
1002 FormControlType::Button
1003 );
1004 assert_eq!(
1005 FormControlType::parse("Button").unwrap(),
1006 FormControlType::Button
1007 );
1008 assert_eq!(
1009 FormControlType::parse("checkbox").unwrap(),
1010 FormControlType::CheckBox
1011 );
1012 assert_eq!(
1013 FormControlType::parse("check_box").unwrap(),
1014 FormControlType::CheckBox
1015 );
1016 assert_eq!(
1017 FormControlType::parse("radio").unwrap(),
1018 FormControlType::OptionButton
1019 );
1020 assert_eq!(
1021 FormControlType::parse("optionButton").unwrap(),
1022 FormControlType::OptionButton
1023 );
1024 assert_eq!(
1025 FormControlType::parse("spin").unwrap(),
1026 FormControlType::SpinButton
1027 );
1028 assert_eq!(
1029 FormControlType::parse("spinner").unwrap(),
1030 FormControlType::SpinButton
1031 );
1032 assert_eq!(
1033 FormControlType::parse("scroll").unwrap(),
1034 FormControlType::ScrollBar
1035 );
1036 assert_eq!(
1037 FormControlType::parse("scrollbar").unwrap(),
1038 FormControlType::ScrollBar
1039 );
1040 assert_eq!(
1041 FormControlType::parse("group").unwrap(),
1042 FormControlType::GroupBox
1043 );
1044 assert_eq!(
1045 FormControlType::parse("groupbox").unwrap(),
1046 FormControlType::GroupBox
1047 );
1048 assert_eq!(
1049 FormControlType::parse("label").unwrap(),
1050 FormControlType::Label
1051 );
1052 assert!(FormControlType::parse("unknown").is_err());
1053 }
1054
1055 #[test]
1056 fn test_form_control_type_object_type() {
1057 assert_eq!(FormControlType::Button.object_type(), "Button");
1058 assert_eq!(FormControlType::CheckBox.object_type(), "Checkbox");
1059 assert_eq!(FormControlType::OptionButton.object_type(), "Radio");
1060 assert_eq!(FormControlType::SpinButton.object_type(), "Spin");
1061 assert_eq!(FormControlType::ScrollBar.object_type(), "Scroll");
1062 assert_eq!(FormControlType::GroupBox.object_type(), "GBox");
1063 assert_eq!(FormControlType::Label.object_type(), "Label");
1064 }
1065
1066 #[test]
1067 fn test_form_control_type_roundtrip() {
1068 let types = vec![
1069 FormControlType::Button,
1070 FormControlType::CheckBox,
1071 FormControlType::OptionButton,
1072 FormControlType::SpinButton,
1073 FormControlType::ScrollBar,
1074 FormControlType::GroupBox,
1075 FormControlType::Label,
1076 ];
1077 for ct in types {
1078 let obj_type = ct.object_type();
1079 let parsed = FormControlType::from_object_type(obj_type).unwrap();
1080 assert_eq!(parsed, ct);
1081 }
1082 }
1083
1084 #[test]
1085 fn test_validate_config_valid() {
1086 let config = FormControlConfig::button("A1", "Click Me");
1087 assert!(config.validate().is_ok());
1088 }
1089
1090 #[test]
1091 fn test_validate_config_invalid_cell() {
1092 let mut config = FormControlConfig::button("INVALID", "Click Me");
1093 config.cell = "ZZZZZ".to_string();
1094 assert!(config.validate().is_err());
1095 }
1096
1097 #[test]
1098 fn test_validate_config_min_exceeds_max() {
1099 let mut config = FormControlConfig::spin_button("A1", 0, 100);
1100 config.min_value = Some(200);
1101 config.max_value = Some(100);
1102 assert!(config.validate().is_err());
1103 }
1104
1105 #[test]
1106 fn test_validate_config_zero_increment() {
1107 let mut config = FormControlConfig::spin_button("A1", 0, 100);
1108 config.increment = Some(0);
1109 assert!(config.validate().is_err());
1110 }
1111
1112 #[test]
1113 fn test_validate_config_zero_page_increment() {
1114 let mut config = FormControlConfig::scroll_bar("A1", 0, 100);
1115 config.page_increment = Some(0);
1116 assert!(config.validate().is_err());
1117 }
1118
1119 #[test]
1120 fn test_validate_config_invalid_cell_link() {
1121 let mut config = FormControlConfig::checkbox("A1", "Check");
1122 config.cell_link = Some("NOT_A_CELL".to_string());
1123 assert!(config.validate().is_err());
1124 }
1125
1126 #[test]
1127 fn test_build_button_vml() {
1128 let config = FormControlConfig::button("B2", "Click Me");
1129 let vml = build_form_control_vml(&[config], 1025);
1130
1131 assert!(vml.contains("xmlns:v=\"urn:schemas-microsoft-com:vml\""));
1132 assert!(vml.contains("xmlns:o=\"urn:schemas-microsoft-com:office:office\""));
1133 assert!(vml.contains("xmlns:x=\"urn:schemas-microsoft-com:office:excel\""));
1134 assert!(vml.contains("ObjectType=\"Button\""));
1135 assert!(vml.contains("Click Me"));
1136 assert!(vml.contains("_x0000_s1025"));
1137 assert!(vml.contains("_x0000_t201"));
1138 assert!(vml.contains("fillcolor=\"buttonFace\""));
1139 }
1140
1141 #[test]
1142 fn test_build_checkbox_vml() {
1143 let mut config = FormControlConfig::checkbox("A1", "Enable Feature");
1144 config.cell_link = Some("$C$1".to_string());
1145 config.checked = Some(true);
1146
1147 let vml = build_form_control_vml(&[config], 1025);
1148 assert!(vml.contains("ObjectType=\"Checkbox\""));
1149 assert!(vml.contains("Enable Feature"));
1150 assert!(vml.contains("<x:FmlaLink>$C$1</x:FmlaLink>"));
1151 assert!(vml.contains("<x:Checked>1</x:Checked>"));
1152 }
1153
1154 #[test]
1155 fn test_build_option_button_vml() {
1156 let config = FormControlConfig {
1157 control_type: FormControlType::OptionButton,
1158 cell: "A3".to_string(),
1159 width: None,
1160 height: None,
1161 text: Some("Option A".to_string()),
1162 macro_name: None,
1163 cell_link: Some("$D$1".to_string()),
1164 checked: Some(false),
1165 min_value: None,
1166 max_value: None,
1167 increment: None,
1168 page_increment: None,
1169 current_value: None,
1170 three_d: None,
1171 };
1172
1173 let vml = build_form_control_vml(&[config], 1025);
1174 assert!(vml.contains("ObjectType=\"Radio\""));
1175 assert!(vml.contains("Option A"));
1176 assert!(vml.contains("<x:FmlaLink>$D$1</x:FmlaLink>"));
1177 assert!(vml.contains("<x:Checked>0</x:Checked>"));
1178 }
1179
1180 #[test]
1181 fn test_build_spin_button_vml() {
1182 let config = FormControlConfig::spin_button("E1", 0, 100);
1183 let vml = build_form_control_vml(&[config], 1025);
1184
1185 assert!(vml.contains("ObjectType=\"Spin\""));
1186 assert!(vml.contains("<x:Min>0</x:Min>"));
1187 assert!(vml.contains("<x:Max>100</x:Max>"));
1188 assert!(vml.contains("<x:Inc>1</x:Inc>"));
1189 assert!(vml.contains("<x:Val>0</x:Val>"));
1190 }
1191
1192 #[test]
1193 fn test_build_scroll_bar_vml() {
1194 let config = FormControlConfig::scroll_bar("F1", 10, 200);
1195 let vml = build_form_control_vml(&[config], 1025);
1196
1197 assert!(vml.contains("ObjectType=\"Scroll\""));
1198 assert!(vml.contains("<x:Min>10</x:Min>"));
1199 assert!(vml.contains("<x:Max>200</x:Max>"));
1200 assert!(vml.contains("<x:Inc>1</x:Inc>"));
1201 assert!(vml.contains("<x:Page>10</x:Page>"));
1202 }
1203
1204 #[test]
1205 fn test_build_group_box_vml() {
1206 let config = FormControlConfig {
1207 control_type: FormControlType::GroupBox,
1208 cell: "A1".to_string(),
1209 width: None,
1210 height: None,
1211 text: Some("Options".to_string()),
1212 macro_name: None,
1213 cell_link: None,
1214 checked: None,
1215 min_value: None,
1216 max_value: None,
1217 increment: None,
1218 page_increment: None,
1219 current_value: None,
1220 three_d: None,
1221 };
1222
1223 let vml = build_form_control_vml(&[config], 1025);
1224 assert!(vml.contains("ObjectType=\"GBox\""));
1225 assert!(vml.contains("Options"));
1226 assert!(vml.contains("filled=\"f\""));
1227 }
1228
1229 #[test]
1230 fn test_build_label_vml() {
1231 let config = FormControlConfig {
1232 control_type: FormControlType::Label,
1233 cell: "A1".to_string(),
1234 width: None,
1235 height: None,
1236 text: Some("Status:".to_string()),
1237 macro_name: None,
1238 cell_link: None,
1239 checked: None,
1240 min_value: None,
1241 max_value: None,
1242 increment: None,
1243 page_increment: None,
1244 current_value: None,
1245 three_d: None,
1246 };
1247
1248 let vml = build_form_control_vml(&[config], 1025);
1249 assert!(vml.contains("ObjectType=\"Label\""));
1250 assert!(vml.contains("Status:"));
1251 }
1252
1253 #[test]
1254 fn test_build_button_with_macro() {
1255 let mut config = FormControlConfig::button("A1", "Run Macro");
1256 config.macro_name = Some("Sheet1.MyMacro".to_string());
1257
1258 let vml = build_form_control_vml(&[config], 1025);
1259 assert!(vml.contains("<x:FmlaMacro>Sheet1.MyMacro</x:FmlaMacro>"));
1260 }
1261
1262 #[test]
1263 fn test_build_control_no_three_d() {
1264 let mut config = FormControlConfig::checkbox("A1", "Flat");
1265 config.three_d = Some(false);
1266
1267 let vml = build_form_control_vml(&[config], 1025);
1268 assert!(vml.contains("<x:NoThreeD/>"));
1269 }
1270
1271 #[test]
1272 fn test_build_multiple_controls() {
1273 let controls = vec![
1274 FormControlConfig::button("A1", "Button 1"),
1275 FormControlConfig::checkbox("A3", "Check 1"),
1276 FormControlConfig::spin_button("C1", 0, 50),
1277 ];
1278
1279 let vml = build_form_control_vml(&controls, 1025);
1280 assert!(vml.contains("_x0000_s1025"));
1281 assert!(vml.contains("_x0000_s1026"));
1282 assert!(vml.contains("_x0000_s1027"));
1283 assert!(vml.contains("ObjectType=\"Button\""));
1284 assert!(vml.contains("ObjectType=\"Checkbox\""));
1285 assert!(vml.contains("ObjectType=\"Spin\""));
1286 }
1287
1288 #[test]
1289 fn test_parse_form_controls_button() {
1290 let config = FormControlConfig::button("B2", "Click Me");
1291 let vml = build_form_control_vml(&[config], 1025);
1292
1293 let controls = parse_form_controls(&vml);
1294 assert_eq!(controls.len(), 1);
1295 assert_eq!(controls[0].control_type, FormControlType::Button);
1296 assert_eq!(controls[0].text.as_deref(), Some("Click Me"));
1297 }
1298
1299 #[test]
1300 fn test_parse_form_control_configs_preserves_dimensions_and_flat_style() {
1301 let mut config = FormControlConfig::button("B2", "Custom");
1302 config.width = Some(200.0);
1303 config.height = Some(40.0);
1304 config.three_d = Some(false);
1305 let vml = build_form_control_vml(&[config], 1025);
1306
1307 let parsed = parse_form_control_configs(&vml);
1308
1309 assert_eq!(parsed.len(), 1);
1310 assert!((parsed[0].width.unwrap() - 200.0).abs() < 0.05);
1311 assert!((parsed[0].height.unwrap() - 40.0).abs() < 0.05);
1312 assert_eq!(parsed[0].three_d, Some(false));
1313 }
1314
1315 #[test]
1316 fn test_form_control_labels_are_xml_escaped_and_round_trip() {
1317 let label = "A & B < \"quoted\" 'text' Café";
1318 let vml = build_form_control_vml(&[FormControlConfig::button("B2", label)], 1025);
1319
1320 assert!(vml.contains("A & B < "quoted" 'text' Café"));
1321 assert_eq!(parse_form_controls(&vml)[0].text.as_deref(), Some(label));
1322 }
1323
1324 #[test]
1325 fn test_control_properties_use_office_tokens() {
1326 let mut checkbox = FormControlConfig::checkbox("B2", "Enabled");
1327 checkbox.checked = Some(true);
1328 checkbox.cell_link = Some("$D$1".to_string());
1329 let checkbox_xml = build_control_property_xml(&checkbox);
1330 let group_xml = build_control_property_xml(&FormControlConfig {
1331 control_type: FormControlType::GroupBox,
1332 cell: "A1".to_string(),
1333 width: None,
1334 height: None,
1335 text: Some("Group".to_string()),
1336 macro_name: None,
1337 cell_link: None,
1338 checked: None,
1339 min_value: None,
1340 max_value: None,
1341 increment: None,
1342 page_increment: None,
1343 current_value: None,
1344 three_d: None,
1345 });
1346
1347 assert!(checkbox_xml.contains("objectType=\"CheckBox\""));
1348 assert!(checkbox_xml.contains("checked=\"Checked\""));
1349 assert!(checkbox_xml.contains("fmlaLink=\"$D$1\""));
1350 assert!(group_xml.contains("objectType=\"GBox\""));
1351 }
1352
1353 #[test]
1354 fn test_validate_rejects_invalid_xml_and_unbounded_dimensions() {
1355 let mut invalid_text = FormControlConfig::button("A1", "bad\u{1}text");
1356 assert!(invalid_text.validate().is_err());
1357
1358 invalid_text.text = Some("Valid".to_string());
1359 invalid_text.width = Some(f64::INFINITY);
1360 assert!(invalid_text.validate().is_err());
1361
1362 let invalid_limit = FormControlConfig::spin_button("A1", 0, 30_001);
1363 assert!(invalid_limit.validate().is_err());
1364
1365 let edge = FormControlConfig::button("XFD1048576", "Edge");
1366 assert!(edge.validate().is_err());
1367 }
1368
1369 #[test]
1370 fn test_parse_form_controls_checkbox_with_link() {
1371 let mut config = FormControlConfig::checkbox("A1", "Toggle");
1372 config.cell_link = Some("$D$1".to_string());
1373 config.checked = Some(true);
1374 let vml = build_form_control_vml(&[config], 1025);
1375
1376 let controls = parse_form_controls(&vml);
1377 assert_eq!(controls.len(), 1);
1378 assert_eq!(controls[0].control_type, FormControlType::CheckBox);
1379 assert_eq!(controls[0].text.as_deref(), Some("Toggle"));
1380 assert_eq!(controls[0].cell_link.as_deref(), Some("$D$1"));
1381 assert_eq!(controls[0].checked, Some(true));
1382 }
1383
1384 #[test]
1385 fn test_parse_form_controls_spin_button() {
1386 let config = FormControlConfig::spin_button("C1", 5, 50);
1387 let vml = build_form_control_vml(&[config], 1025);
1388
1389 let controls = parse_form_controls(&vml);
1390 assert_eq!(controls.len(), 1);
1391 assert_eq!(controls[0].control_type, FormControlType::SpinButton);
1392 assert_eq!(controls[0].min_value, Some(5));
1393 assert_eq!(controls[0].max_value, Some(50));
1394 assert_eq!(controls[0].increment, Some(1));
1395 assert_eq!(controls[0].current_value, Some(5));
1396 }
1397
1398 #[test]
1399 fn test_parse_form_controls_scroll_bar() {
1400 let config = FormControlConfig::scroll_bar("E1", 0, 100);
1401 let vml = build_form_control_vml(&[config], 1025);
1402
1403 let controls = parse_form_controls(&vml);
1404 assert_eq!(controls.len(), 1);
1405 assert_eq!(controls[0].control_type, FormControlType::ScrollBar);
1406 assert_eq!(controls[0].page_increment, Some(10));
1407 }
1408
1409 #[test]
1410 fn test_parse_multiple_controls() {
1411 let controls = vec![
1412 FormControlConfig::button("A1", "Btn"),
1413 FormControlConfig::checkbox("A3", "Chk"),
1414 FormControlConfig::spin_button("C1", 0, 10),
1415 ];
1416 let vml = build_form_control_vml(&controls, 1025);
1417
1418 let parsed = parse_form_controls(&vml);
1419 assert_eq!(parsed.len(), 3);
1420 assert_eq!(parsed[0].control_type, FormControlType::Button);
1421 assert_eq!(parsed[1].control_type, FormControlType::CheckBox);
1422 assert_eq!(parsed[2].control_type, FormControlType::SpinButton);
1423 }
1424
1425 #[test]
1426 fn test_parse_ignores_comment_shapes() {
1427 let comment_vml = crate::vml::build_vml_drawing(&["A1"]);
1429 let controls = parse_form_controls(&comment_vml);
1430 assert!(controls.is_empty(), "comment shapes should be ignored");
1431 }
1432
1433 #[test]
1434 fn test_count_vml_shapes() {
1435 let vml = build_form_control_vml(
1436 &[
1437 FormControlConfig::button("A1", "B1"),
1438 FormControlConfig::checkbox("A3", "C1"),
1439 ],
1440 1025,
1441 );
1442 assert_eq!(count_vml_shapes(vml.as_bytes()), 2);
1443 }
1444
1445 #[test]
1446 fn test_merge_vml_controls() {
1447 let existing = build_form_control_vml(&[FormControlConfig::button("A1", "First")], 1025);
1448 let new_controls = vec![FormControlConfig::checkbox("A3", "Second")];
1449 let merged = merge_vml_controls(existing.as_bytes(), &new_controls, 1026);
1450 let merged_str = String::from_utf8(merged).unwrap();
1451
1452 assert!(merged_str.contains("_x0000_s1025"));
1453 assert!(merged_str.contains("_x0000_s1026"));
1454 assert!(merged_str.contains("ObjectType=\"Button\""));
1455 assert!(merged_str.contains("ObjectType=\"Checkbox\""));
1456 let shapetype_count = merged_str.matches(FORM_CONTROL_SHAPETYPE_ID).count();
1458 assert!(shapetype_count >= 2);
1460 }
1461
1462 #[test]
1463 fn test_build_control_anchor_basic() {
1464 let anchor = build_control_anchor("A1", 72.0, 24.0).unwrap();
1465 assert_eq!(anchor, "0, 15, 0, 10, 1, 527, 1, 164");
1466 }
1467
1468 #[test]
1469 fn test_build_control_anchor_offset_cell() {
1470 let anchor = build_control_anchor("C5", 72.0, 30.0).unwrap();
1471 assert_eq!(anchor, "2, 15, 4, 10, 3, 527, 6, 10");
1472 }
1473
1474 #[test]
1475 fn test_build_control_anchor_invalid_cell() {
1476 assert!(build_control_anchor("INVALID", 72.0, 24.0).is_err());
1477 }
1478
1479 #[test]
1480 fn test_default_dimensions() {
1481 let (w, h) = default_dimensions(&FormControlType::Button);
1482 assert_eq!(w, 72.0);
1483 assert_eq!(h, 24.0);
1484
1485 let (w, h) = default_dimensions(&FormControlType::ScrollBar);
1486 assert_eq!(w, 15.75);
1487 assert_eq!(h, 60.0);
1488 }
1489
1490 #[test]
1491 fn test_extract_anchor_cell() {
1492 let cd = "<x:ClientData ObjectType=\"Button\"><x:Anchor>1, 15, 0, 10, 3, 63, 2, 24</x:Anchor></x:ClientData>";
1493 let cell = extract_anchor_cell(cd).unwrap();
1494 assert_eq!(cell, "B1");
1495 }
1496
1497 #[test]
1498 fn test_custom_dimensions() {
1499 let mut config = FormControlConfig::button("A1", "Wide");
1500 config.width = Some(200.0);
1501 config.height = Some(50.0);
1502 let vml = build_form_control_vml(&[config], 1025);
1503 assert!(vml.contains("_x0000_s1025"));
1504 }
1505
1506 #[test]
1507 fn test_workbook_add_form_control() {
1508 use crate::workbook::Workbook;
1509
1510 let mut wb = Workbook::new();
1511 let config = FormControlConfig::button("B2", "Click Me");
1512 wb.add_form_control("Sheet1", config).unwrap();
1513
1514 let controls = wb.get_form_controls("Sheet1").unwrap();
1515 assert_eq!(controls.len(), 1);
1516 assert_eq!(controls[0].control_type, FormControlType::Button);
1517 assert_eq!(controls[0].text.as_deref(), Some("Click Me"));
1518 }
1519
1520 #[test]
1521 fn test_workbook_add_multiple_form_controls() {
1522 use crate::workbook::Workbook;
1523
1524 let mut wb = Workbook::new();
1525 wb.add_form_control("Sheet1", FormControlConfig::button("A1", "Button 1"))
1526 .unwrap();
1527 wb.add_form_control("Sheet1", FormControlConfig::checkbox("A3", "Check 1"))
1528 .unwrap();
1529 wb.add_form_control("Sheet1", FormControlConfig::spin_button("C1", 0, 100))
1530 .unwrap();
1531
1532 let controls = wb.get_form_controls("Sheet1").unwrap();
1533 assert_eq!(controls.len(), 3);
1534 assert_eq!(controls[0].control_type, FormControlType::Button);
1535 assert_eq!(controls[1].control_type, FormControlType::CheckBox);
1536 assert_eq!(controls[2].control_type, FormControlType::SpinButton);
1537 }
1538
1539 #[test]
1540 fn test_workbook_add_form_control_sheet_not_found() {
1541 use crate::workbook::Workbook;
1542
1543 let mut wb = Workbook::new();
1544 let config = FormControlConfig::button("A1", "Test");
1545 let result = wb.add_form_control("NoSheet", config);
1546 assert!(result.is_err());
1547 }
1548
1549 #[test]
1550 fn test_workbook_add_form_control_invalid_cell() {
1551 use crate::workbook::Workbook;
1552
1553 let mut wb = Workbook::new();
1554 let config = FormControlConfig {
1555 control_type: FormControlType::Button,
1556 cell: "INVALID".to_string(),
1557 width: None,
1558 height: None,
1559 text: Some("Test".to_string()),
1560 macro_name: None,
1561 cell_link: None,
1562 checked: None,
1563 min_value: None,
1564 max_value: None,
1565 increment: None,
1566 page_increment: None,
1567 current_value: None,
1568 three_d: None,
1569 };
1570 let result = wb.add_form_control("Sheet1", config);
1571 assert!(result.is_err());
1572 }
1573
1574 #[test]
1575 fn test_workbook_delete_form_control() {
1576 use crate::workbook::Workbook;
1577
1578 let mut wb = Workbook::new();
1579 wb.add_form_control("Sheet1", FormControlConfig::button("A1", "Btn 1"))
1580 .unwrap();
1581 wb.add_form_control("Sheet1", FormControlConfig::checkbox("A3", "Chk 1"))
1582 .unwrap();
1583
1584 wb.delete_form_control("Sheet1", 0).unwrap();
1585
1586 let controls = wb.get_form_controls("Sheet1").unwrap();
1587 assert_eq!(controls.len(), 1);
1588 assert_eq!(controls[0].control_type, FormControlType::CheckBox);
1589 }
1590
1591 #[test]
1592 fn test_workbook_delete_form_control_out_of_bounds() {
1593 use crate::workbook::Workbook;
1594
1595 let mut wb = Workbook::new();
1596 wb.add_form_control("Sheet1", FormControlConfig::button("A1", "Btn"))
1597 .unwrap();
1598 let result = wb.delete_form_control("Sheet1", 5);
1599 assert!(result.is_err());
1600 }
1601
1602 #[test]
1603 fn test_workbook_form_control_save_roundtrip() {
1604 use crate::workbook::Workbook;
1605 use tempfile::TempDir;
1606
1607 let dir = TempDir::new().unwrap();
1608 let path = dir.path().join("form_controls.xlsx");
1609
1610 let mut wb = Workbook::new();
1611 let mut btn = FormControlConfig::button("B2", "Submit");
1612 btn.macro_name = Some("Sheet1.OnSubmit".to_string());
1613 wb.add_form_control("Sheet1", btn).unwrap();
1614
1615 let mut chk = FormControlConfig::checkbox("B4", "Agree");
1616 chk.cell_link = Some("$D$4".to_string());
1617 chk.checked = Some(true);
1618 wb.add_form_control("Sheet1", chk).unwrap();
1619
1620 wb.add_form_control("Sheet1", FormControlConfig::spin_button("E2", 0, 100))
1621 .unwrap();
1622
1623 wb.save(&path).unwrap();
1624
1625 let file = std::fs::File::open(&path).unwrap();
1627 let mut archive = zip::ZipArchive::new(file).unwrap();
1628
1629 let has_vml = (1..=10).any(|i| {
1630 archive
1631 .by_name(&format!("xl/drawings/vmlDrawing{i}.vml"))
1632 .is_ok()
1633 });
1634 assert!(has_vml, "should have a vmlDrawing file in the ZIP");
1635
1636 let opts = crate::workbook::OpenOptions::new()
1638 .read_mode(crate::workbook::ReadMode::Eager)
1639 .aux_parts(crate::workbook::AuxParts::EagerLoad);
1640 let mut wb2 = Workbook::open_with_options(&path, &opts).unwrap();
1641 let controls = wb2.get_form_controls("Sheet1").unwrap();
1642 assert_eq!(controls.len(), 3);
1643 assert_eq!(controls[0].control_type, FormControlType::Button);
1644 assert_eq!(controls[0].text.as_deref(), Some("Submit"));
1645 assert_eq!(controls[0].macro_name.as_deref(), Some("Sheet1.OnSubmit"));
1646 assert_eq!(controls[1].control_type, FormControlType::CheckBox);
1647 assert_eq!(controls[1].cell_link.as_deref(), Some("$D$4"));
1648 assert_eq!(controls[1].checked, Some(true));
1649 assert_eq!(controls[2].control_type, FormControlType::SpinButton);
1650 assert_eq!(controls[2].min_value, Some(0));
1651 assert_eq!(controls[2].max_value, Some(100));
1652 }
1653
1654 #[test]
1655 fn test_workbook_form_control_all_7_types() {
1656 use crate::workbook::Workbook;
1657
1658 let mut wb = Workbook::new();
1659 wb.add_form_control("Sheet1", FormControlConfig::button("A1", "Button"))
1660 .unwrap();
1661 wb.add_form_control("Sheet1", FormControlConfig::checkbox("A3", "Checkbox"))
1662 .unwrap();
1663 wb.add_form_control(
1664 "Sheet1",
1665 FormControlConfig {
1666 control_type: FormControlType::OptionButton,
1667 cell: "A5".to_string(),
1668 width: None,
1669 height: None,
1670 text: Some("Option".to_string()),
1671 macro_name: None,
1672 cell_link: None,
1673 checked: None,
1674 min_value: None,
1675 max_value: None,
1676 increment: None,
1677 page_increment: None,
1678 current_value: None,
1679 three_d: None,
1680 },
1681 )
1682 .unwrap();
1683 wb.add_form_control("Sheet1", FormControlConfig::spin_button("C1", 0, 10))
1684 .unwrap();
1685 wb.add_form_control("Sheet1", FormControlConfig::scroll_bar("E1", 0, 100))
1686 .unwrap();
1687 wb.add_form_control(
1688 "Sheet1",
1689 FormControlConfig {
1690 control_type: FormControlType::GroupBox,
1691 cell: "G1".to_string(),
1692 width: None,
1693 height: None,
1694 text: Some("Group".to_string()),
1695 macro_name: None,
1696 cell_link: None,
1697 checked: None,
1698 min_value: None,
1699 max_value: None,
1700 increment: None,
1701 page_increment: None,
1702 current_value: None,
1703 three_d: None,
1704 },
1705 )
1706 .unwrap();
1707 wb.add_form_control(
1708 "Sheet1",
1709 FormControlConfig {
1710 control_type: FormControlType::Label,
1711 cell: "I1".to_string(),
1712 width: None,
1713 height: None,
1714 text: Some("Label Text".to_string()),
1715 macro_name: None,
1716 cell_link: None,
1717 checked: None,
1718 min_value: None,
1719 max_value: None,
1720 increment: None,
1721 page_increment: None,
1722 current_value: None,
1723 three_d: None,
1724 },
1725 )
1726 .unwrap();
1727
1728 let controls = wb.get_form_controls("Sheet1").unwrap();
1729 assert_eq!(controls.len(), 7);
1730 assert_eq!(controls[0].control_type, FormControlType::Button);
1731 assert_eq!(controls[1].control_type, FormControlType::CheckBox);
1732 assert_eq!(controls[2].control_type, FormControlType::OptionButton);
1733 assert_eq!(controls[3].control_type, FormControlType::SpinButton);
1734 assert_eq!(controls[4].control_type, FormControlType::ScrollBar);
1735 assert_eq!(controls[5].control_type, FormControlType::GroupBox);
1736 assert_eq!(controls[6].control_type, FormControlType::Label);
1737 }
1738
1739 #[test]
1740 fn test_workbook_form_control_with_comments() {
1741 use crate::workbook::Workbook;
1742 use tempfile::TempDir;
1743
1744 let dir = TempDir::new().unwrap();
1745 let path = dir.path().join("controls_and_comments.xlsx");
1746
1747 let mut wb = Workbook::new();
1748 wb.add_comment(
1749 "Sheet1",
1750 &crate::comment::CommentConfig {
1751 cell: "A1".to_string(),
1752 author: "Author".to_string(),
1753 text: "A comment".to_string(),
1754 },
1755 )
1756 .unwrap();
1757 wb.add_form_control("Sheet1", FormControlConfig::button("C1", "Button"))
1758 .unwrap();
1759 wb.save(&path).unwrap();
1760
1761 let mut wb2 = Workbook::open(&path).unwrap();
1762 let comments = wb2.get_comments("Sheet1").unwrap();
1763 assert_eq!(comments.len(), 1);
1764 let controls = wb2.get_form_controls("Sheet1").unwrap();
1765 assert_eq!(controls.len(), 1);
1766 assert_eq!(controls[0].control_type, FormControlType::Button);
1767 }
1768
1769 #[test]
1770 fn test_workbook_get_form_controls_empty() {
1771 use crate::workbook::Workbook;
1772
1773 let mut wb = Workbook::new();
1774 let controls = wb.get_form_controls("Sheet1").unwrap();
1775 assert!(controls.is_empty());
1776 }
1777
1778 #[test]
1779 fn test_workbook_get_form_controls_sheet_not_found() {
1780 use crate::workbook::Workbook;
1781
1782 let mut wb = Workbook::new();
1783 let result = wb.get_form_controls("NoSheet");
1784 assert!(result.is_err());
1785 }
1786
1787 #[test]
1788 fn test_open_file_get_form_controls_returns_existing() {
1789 use crate::workbook::Workbook;
1790 use crate::workbook::{AuxParts, OpenOptions, ReadMode};
1791 use tempfile::TempDir;
1792
1793 let dir = TempDir::new().unwrap();
1794 let path = dir.path().join("get_existing.xlsx");
1795
1796 let mut wb = Workbook::new();
1797 wb.add_form_control("Sheet1", FormControlConfig::button("A1", "Existing"))
1798 .unwrap();
1799 wb.add_form_control("Sheet1", FormControlConfig::checkbox("A3", "Check"))
1800 .unwrap();
1801 wb.save(&path).unwrap();
1802
1803 let opts = OpenOptions::new()
1804 .read_mode(ReadMode::Eager)
1805 .aux_parts(AuxParts::EagerLoad);
1806 let mut wb2 = Workbook::open_with_options(&path, &opts).unwrap();
1807 let controls = wb2.get_form_controls("Sheet1").unwrap();
1808 assert_eq!(controls.len(), 2);
1809 assert_eq!(controls[0].control_type, FormControlType::Button);
1810 assert_eq!(controls[0].text.as_deref(), Some("Existing"));
1811 assert_eq!(controls[1].control_type, FormControlType::CheckBox);
1812 assert_eq!(controls[1].text.as_deref(), Some("Check"));
1813 }
1814
1815 #[test]
1816 fn test_open_file_add_form_control_preserves_existing() {
1817 use crate::workbook::Workbook;
1818 use crate::workbook::{AuxParts, OpenOptions, ReadMode};
1819 use tempfile::TempDir;
1820
1821 let dir = TempDir::new().unwrap();
1822 let path = dir.path().join("add_preserves.xlsx");
1823
1824 let mut wb = Workbook::new();
1825 wb.add_form_control("Sheet1", FormControlConfig::button("A1", "First"))
1826 .unwrap();
1827 wb.add_form_control("Sheet1", FormControlConfig::checkbox("A3", "Second"))
1828 .unwrap();
1829 wb.save(&path).unwrap();
1830
1831 let opts = OpenOptions::new()
1832 .read_mode(ReadMode::Eager)
1833 .aux_parts(AuxParts::EagerLoad);
1834 let mut wb2 = Workbook::open_with_options(&path, &opts).unwrap();
1835 wb2.add_form_control("Sheet1", FormControlConfig::spin_button("C1", 0, 50))
1836 .unwrap();
1837
1838 let controls = wb2.get_form_controls("Sheet1").unwrap();
1839 assert_eq!(
1840 controls.len(),
1841 3,
1842 "old + new controls should all be present"
1843 );
1844 assert_eq!(controls[0].control_type, FormControlType::Button);
1845 assert_eq!(controls[0].text.as_deref(), Some("First"));
1846 assert_eq!(controls[1].control_type, FormControlType::CheckBox);
1847 assert_eq!(controls[1].text.as_deref(), Some("Second"));
1848 assert_eq!(controls[2].control_type, FormControlType::SpinButton);
1849 assert_eq!(controls[2].min_value, Some(0));
1850 assert_eq!(controls[2].max_value, Some(50));
1851 }
1852
1853 #[test]
1854 fn test_open_file_delete_form_control_works() {
1855 use crate::workbook::Workbook;
1856 use crate::workbook::{AuxParts, OpenOptions, ReadMode};
1857 use tempfile::TempDir;
1858
1859 let dir = TempDir::new().unwrap();
1860 let path = dir.path().join("delete_works.xlsx");
1861
1862 let mut wb = Workbook::new();
1863 wb.add_form_control("Sheet1", FormControlConfig::button("A1", "First"))
1864 .unwrap();
1865 wb.add_form_control("Sheet1", FormControlConfig::checkbox("A3", "Second"))
1866 .unwrap();
1867 wb.add_form_control("Sheet1", FormControlConfig::spin_button("C1", 0, 10))
1868 .unwrap();
1869 wb.save(&path).unwrap();
1870
1871 let opts = OpenOptions::new()
1872 .read_mode(ReadMode::Eager)
1873 .aux_parts(AuxParts::EagerLoad);
1874 let mut wb2 = Workbook::open_with_options(&path, &opts).unwrap();
1875 wb2.delete_form_control("Sheet1", 1).unwrap();
1876
1877 let controls = wb2.get_form_controls("Sheet1").unwrap();
1878 assert_eq!(controls.len(), 2);
1879 assert_eq!(controls[0].control_type, FormControlType::Button);
1880 assert_eq!(controls[1].control_type, FormControlType::SpinButton);
1881 }
1882
1883 #[test]
1884 fn test_failed_delete_form_control_preserves_vml_after_save_reopen() {
1885 use crate::workbook::Workbook;
1886 use crate::workbook::{AuxParts, OpenOptions, ReadMode};
1887
1888 let mut wb = Workbook::new();
1889 wb.add_form_control("Sheet1", FormControlConfig::button("A1", "Preserve"))
1890 .unwrap();
1891 let source = wb.save_to_buffer().unwrap();
1892 let opts = OpenOptions::new()
1893 .read_mode(ReadMode::Eager)
1894 .aux_parts(AuxParts::EagerLoad);
1895 let mut reopened = Workbook::open_from_buffer_with_options(&source, &opts).unwrap();
1896
1897 assert!(reopened.delete_form_control("Sheet1", 1).is_err());
1898
1899 let saved = reopened.save_to_buffer().unwrap();
1900 let mut roundtripped = Workbook::open_from_buffer_with_options(&saved, &opts).unwrap();
1901 let controls = roundtripped.get_form_controls("Sheet1").unwrap();
1902 assert_eq!(controls.len(), 1);
1903 assert_eq!(controls[0].text.as_deref(), Some("Preserve"));
1904 }
1905
1906 #[test]
1907 fn test_open_file_modify_save_reopen_persistence() {
1908 use crate::workbook::Workbook;
1909 use crate::workbook::{AuxParts, OpenOptions, ReadMode};
1910 use tempfile::TempDir;
1911
1912 let dir = TempDir::new().unwrap();
1913 let path1 = dir.path().join("persistence_step1.xlsx");
1914 let path2 = dir.path().join("persistence_step2.xlsx");
1915
1916 let opts = OpenOptions::new()
1917 .read_mode(ReadMode::Eager)
1918 .aux_parts(AuxParts::EagerLoad);
1919
1920 let mut wb = Workbook::new();
1922 wb.add_form_control("Sheet1", FormControlConfig::button("A1", "Button"))
1923 .unwrap();
1924 wb.add_form_control("Sheet1", FormControlConfig::checkbox("A3", "Check"))
1925 .unwrap();
1926 wb.save(&path1).unwrap();
1927
1928 let mut wb2 = Workbook::open_with_options(&path1, &opts).unwrap();
1930 wb2.add_form_control("Sheet1", FormControlConfig::scroll_bar("E1", 0, 100))
1931 .unwrap();
1932 wb2.delete_form_control("Sheet1", 0).unwrap();
1933 wb2.save(&path2).unwrap();
1934
1935 let mut wb3 = Workbook::open_with_options(&path2, &opts).unwrap();
1937 let controls = wb3.get_form_controls("Sheet1").unwrap();
1938 assert_eq!(controls.len(), 2);
1939 assert_eq!(controls[0].control_type, FormControlType::CheckBox);
1940 assert_eq!(controls[0].text.as_deref(), Some("Check"));
1941 assert_eq!(controls[1].control_type, FormControlType::ScrollBar);
1942 assert_eq!(controls[1].min_value, Some(0));
1943 assert_eq!(controls[1].max_value, Some(100));
1944 }
1945
1946 #[test]
1947 fn test_info_to_config_roundtrip() {
1948 let config = FormControlConfig {
1949 control_type: FormControlType::CheckBox,
1950 cell: "B2".to_string(),
1951 width: None,
1952 height: None,
1953 text: Some("Toggle".to_string()),
1954 macro_name: Some("MyMacro".to_string()),
1955 cell_link: Some("$D$1".to_string()),
1956 checked: Some(true),
1957 min_value: None,
1958 max_value: None,
1959 increment: None,
1960 page_increment: None,
1961 current_value: None,
1962 three_d: None,
1963 };
1964
1965 let vml = build_form_control_vml(&[config.clone()], 1025);
1966 let parsed = parse_form_controls(&vml);
1967 assert_eq!(parsed.len(), 1);
1968 let roundtripped = parsed[0].to_config();
1969 assert_eq!(roundtripped.control_type, config.control_type);
1970 assert_eq!(roundtripped.text, config.text);
1971 assert_eq!(roundtripped.macro_name, config.macro_name);
1972 assert_eq!(roundtripped.cell_link, config.cell_link);
1973 assert_eq!(roundtripped.checked, config.checked);
1974 }
1975
1976 #[test]
1977 fn test_strip_form_control_shapes_controls_only() {
1978 let vml = build_form_control_vml(
1979 &[
1980 FormControlConfig::button("A1", "Btn"),
1981 FormControlConfig::checkbox("A3", "Chk"),
1982 ],
1983 1025,
1984 );
1985 let result = strip_form_control_shapes_from_vml(vml.as_bytes());
1986 assert!(
1987 result.is_none(),
1988 "should return None when no comment shapes remain"
1989 );
1990 }
1991
1992 #[test]
1993 fn test_strip_form_control_shapes_mixed() {
1994 let comment_vml = crate::vml::build_vml_drawing(&["A1"]);
1996 let controls = vec![FormControlConfig::button("C1", "Click")];
1997 let mixed = merge_vml_controls(comment_vml.as_bytes(), &controls, 1026);
1998
1999 let mixed_str = String::from_utf8_lossy(&mixed);
2000 assert!(mixed_str.contains("ObjectType=\"Note\""));
2001 assert!(mixed_str.contains("ObjectType=\"Button\""));
2002
2003 let stripped = strip_form_control_shapes_from_vml(&mixed).unwrap();
2004 let stripped_str = String::from_utf8(stripped).unwrap();
2005 assert!(
2006 stripped_str.contains("ObjectType=\"Note\""),
2007 "comment shapes should be preserved"
2008 );
2009 assert!(
2010 !stripped_str.contains("ObjectType=\"Button\""),
2011 "form control shapes should be removed"
2012 );
2013 }
2014
2015 #[test]
2016 fn test_hydration_does_not_duplicate_on_save() {
2017 use crate::workbook::Workbook;
2018 use crate::workbook::{AuxParts, OpenOptions, ReadMode};
2019 use tempfile::TempDir;
2020
2021 let dir = TempDir::new().unwrap();
2022 let path1 = dir.path().join("no_dup_step1.xlsx");
2023 let path2 = dir.path().join("no_dup_step2.xlsx");
2024
2025 let opts = OpenOptions::new()
2026 .read_mode(ReadMode::Eager)
2027 .aux_parts(AuxParts::EagerLoad);
2028
2029 let mut wb = Workbook::new();
2030 wb.add_form_control("Sheet1", FormControlConfig::button("A1", "Btn"))
2031 .unwrap();
2032 wb.add_form_control("Sheet1", FormControlConfig::checkbox("A3", "Chk"))
2033 .unwrap();
2034 wb.save(&path1).unwrap();
2035
2036 let mut wb2 = Workbook::open_with_options(&path1, &opts).unwrap();
2038 let controls = wb2.get_form_controls("Sheet1").unwrap();
2039 assert_eq!(controls.len(), 2);
2040
2041 wb2.save(&path2).unwrap();
2043
2044 let mut wb3 = Workbook::open_with_options(&path2, &opts).unwrap();
2046 let controls3 = wb3.get_form_controls("Sheet1").unwrap();
2047 assert_eq!(
2048 controls3.len(),
2049 2,
2050 "control count must be stable after hydrate+save cycle"
2051 );
2052 assert_eq!(controls3[0].control_type, FormControlType::Button);
2053 assert_eq!(controls3[1].control_type, FormControlType::CheckBox);
2054 }
2055
2056 #[test]
2057 fn test_hydration_then_add_no_duplication() {
2058 use crate::workbook::Workbook;
2059 use crate::workbook::{AuxParts, OpenOptions, ReadMode};
2060 use tempfile::TempDir;
2061
2062 let dir = TempDir::new().unwrap();
2063 let path1 = dir.path().join("add_no_dup_step1.xlsx");
2064 let path2 = dir.path().join("add_no_dup_step2.xlsx");
2065
2066 let opts = OpenOptions::new()
2067 .read_mode(ReadMode::Eager)
2068 .aux_parts(AuxParts::EagerLoad);
2069
2070 let mut wb = Workbook::new();
2071 wb.add_form_control("Sheet1", FormControlConfig::button("A1", "Existing"))
2072 .unwrap();
2073 wb.save(&path1).unwrap();
2074
2075 let mut wb2 = Workbook::open_with_options(&path1, &opts).unwrap();
2077 wb2.add_form_control("Sheet1", FormControlConfig::checkbox("A3", "New"))
2078 .unwrap();
2079 wb2.save(&path2).unwrap();
2080
2081 let mut wb3 = Workbook::open_with_options(&path2, &opts).unwrap();
2083 let controls = wb3.get_form_controls("Sheet1").unwrap();
2084 assert_eq!(controls.len(), 2, "should have exactly 1 existing + 1 new");
2085 assert_eq!(controls[0].control_type, FormControlType::Button);
2086 assert_eq!(controls[0].text.as_deref(), Some("Existing"));
2087 assert_eq!(controls[1].control_type, FormControlType::CheckBox);
2088 assert_eq!(controls[1].text.as_deref(), Some("New"));
2089 }
2090
2091 #[test]
2092 fn test_hydration_with_comments_no_duplication() {
2093 use crate::workbook::Workbook;
2094 use crate::workbook::{AuxParts, OpenOptions, ReadMode};
2095 use tempfile::TempDir;
2096
2097 let dir = TempDir::new().unwrap();
2098 let path1 = dir.path().join("comments_no_dup_step1.xlsx");
2099 let path2 = dir.path().join("comments_no_dup_step2.xlsx");
2100
2101 let opts = OpenOptions::new()
2102 .read_mode(ReadMode::Eager)
2103 .aux_parts(AuxParts::EagerLoad);
2104
2105 let mut wb = Workbook::new();
2106 wb.add_comment(
2107 "Sheet1",
2108 &crate::comment::CommentConfig {
2109 cell: "A1".to_string(),
2110 author: "Author".to_string(),
2111 text: "A comment".to_string(),
2112 },
2113 )
2114 .unwrap();
2115 wb.add_form_control("Sheet1", FormControlConfig::button("C1", "Btn"))
2116 .unwrap();
2117 wb.save(&path1).unwrap();
2118
2119 let mut wb2 = Workbook::open_with_options(&path1, &opts).unwrap();
2121 let controls = wb2.get_form_controls("Sheet1").unwrap();
2122 assert_eq!(controls.len(), 1);
2123 let comments = wb2.get_comments("Sheet1").unwrap();
2124 assert_eq!(comments.len(), 1);
2125 wb2.save(&path2).unwrap();
2126
2127 let mut wb3 = Workbook::open_with_options(&path2, &opts).unwrap();
2129 let controls3 = wb3.get_form_controls("Sheet1").unwrap();
2130 assert_eq!(
2131 controls3.len(),
2132 1,
2133 "form controls must not be duplicated when mixed with comments"
2134 );
2135 assert_eq!(controls3[0].control_type, FormControlType::Button);
2136 let comments3 = wb3.get_comments("Sheet1").unwrap();
2137 assert_eq!(comments3.len(), 1);
2138 assert_eq!(comments3[0].text, "A comment");
2139 }
2140
2141 #[test]
2142 fn test_multiple_hydrate_save_cycles_stable_count() {
2143 use crate::workbook::Workbook;
2144 use crate::workbook::{AuxParts, OpenOptions, ReadMode};
2145 use tempfile::TempDir;
2146
2147 let dir = TempDir::new().unwrap();
2148 let mut prev_path = dir.path().join("cycle_0.xlsx");
2149
2150 let opts = OpenOptions::new()
2151 .read_mode(ReadMode::Eager)
2152 .aux_parts(AuxParts::EagerLoad);
2153
2154 let mut wb = Workbook::new();
2155 wb.add_form_control("Sheet1", FormControlConfig::button("A1", "Btn"))
2156 .unwrap();
2157 wb.add_form_control("Sheet1", FormControlConfig::spin_button("C1", 0, 50))
2158 .unwrap();
2159 wb.save(&prev_path).unwrap();
2160
2161 for i in 1..=3 {
2163 let next_path = dir.path().join(format!("cycle_{i}.xlsx"));
2164 let mut wb_n = Workbook::open_with_options(&prev_path, &opts).unwrap();
2165 let controls = wb_n.get_form_controls("Sheet1").unwrap();
2166 assert_eq!(
2167 controls.len(),
2168 2,
2169 "cycle {i}: control count should remain 2"
2170 );
2171 wb_n.save(&next_path).unwrap();
2172 prev_path = next_path;
2173 }
2174 }
2175
2176 #[test]
2177 fn test_save_without_get_preserves_controls() {
2178 use crate::workbook::Workbook;
2179 use crate::workbook::{AuxParts, OpenOptions, ReadMode};
2180 use tempfile::TempDir;
2181
2182 let dir = TempDir::new().unwrap();
2183 let path1 = dir.path().join("no_get_step1.xlsx");
2184 let path2 = dir.path().join("no_get_step2.xlsx");
2185
2186 let opts = OpenOptions::new()
2187 .read_mode(ReadMode::Eager)
2188 .aux_parts(AuxParts::EagerLoad);
2189
2190 let mut wb = Workbook::new();
2191 wb.add_form_control("Sheet1", FormControlConfig::button("A1", "Btn"))
2192 .unwrap();
2193 wb.add_form_control("Sheet1", FormControlConfig::checkbox("A3", "Chk"))
2194 .unwrap();
2195 wb.save(&path1).unwrap();
2196
2197 let wb2 = Workbook::open_with_options(&path1, &opts).unwrap();
2199 wb2.save(&path2).unwrap();
2200
2201 let mut wb3 = Workbook::open_with_options(&path2, &opts).unwrap();
2203 let controls = wb3.get_form_controls("Sheet1").unwrap();
2204 assert_eq!(
2205 controls.len(),
2206 2,
2207 "controls must be preserved when saving without hydration"
2208 );
2209 assert_eq!(controls[0].control_type, FormControlType::Button);
2210 assert_eq!(controls[1].control_type, FormControlType::CheckBox);
2211 }
2212}