Skip to main content

sheetkit_core/
control.rs

1//! Form control support for Excel worksheets.
2//!
3//! Excel uses legacy VML (Vector Markup Language) drawing parts for form
4//! controls such as buttons, check boxes, option buttons, spin buttons,
5//! scroll bars, group boxes, and labels. This module generates the VML
6//! markup needed to add form controls and parses existing VML to read
7//! them back.
8
9use 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/// Form control types.
23#[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    /// Return the VML ObjectType string for x:ClientData.
36    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    /// Parse an ObjectType string back into a FormControlType.
49    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    /// Parse a user-facing type string into a FormControlType.
63    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/// Configuration for adding a form control to a worksheet.
82#[derive(Debug, Clone)]
83pub struct FormControlConfig {
84    /// The type of form control.
85    pub control_type: FormControlType,
86    /// Anchor cell (top-left corner), e.g. "B2".
87    pub cell: String,
88    /// Width in points. Uses a sensible default per control type if None.
89    pub width: Option<f64>,
90    /// Height in points. Uses a sensible default per control type if None.
91    pub height: Option<f64>,
92    /// Display text (Button, CheckBox, OptionButton, GroupBox, Label).
93    pub text: Option<String>,
94    /// VBA macro name (Button only).
95    pub macro_name: Option<String>,
96    /// Linked cell reference for value binding (CheckBox, OptionButton, SpinButton, ScrollBar).
97    pub cell_link: Option<String>,
98    /// Initial checked state (CheckBox, OptionButton).
99    pub checked: Option<bool>,
100    /// Minimum value (SpinButton, ScrollBar).
101    pub min_value: Option<u32>,
102    /// Maximum value (SpinButton, ScrollBar).
103    pub max_value: Option<u32>,
104    /// Step increment (SpinButton, ScrollBar).
105    pub increment: Option<u32>,
106    /// Page increment (ScrollBar only).
107    pub page_increment: Option<u32>,
108    /// Current value (SpinButton, ScrollBar).
109    pub current_value: Option<u32>,
110    /// Enable 3D shading (default true for most controls).
111    pub three_d: Option<bool>,
112}
113
114impl FormControlConfig {
115    /// Create a Button configuration.
116    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    /// Create a CheckBox configuration.
136    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    /// Create a SpinButton configuration.
156    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    /// Create a ScrollBar configuration.
176    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    /// Validate the configuration for correctness.
196    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/// Information about an existing form control, returned when querying.
263#[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
278/// Build the modern control-property part paired with the VML fallback.
279pub(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
330/// Default dimensions (width, height) in points for each control type.
331fn 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
343/// VML shapetype id for form controls (differs from comments which use t202).
344const FORM_CONTROL_SHAPETYPE_ID: &str = "_x0000_t201";
345
346/// Build the VML anchor string from a cell reference and optional dimensions.
347///
348/// The anchor format is: col1, col1Off, row1, row1Off, col2, col2Off, row2, row2Off.
349/// Offsets are in units of 1/1024 column width or 1/256 row height.
350fn 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
414/// Build a complete VML drawing document containing form control shapes.
415///
416/// `controls` is a list of FormControlConfig entries that have been validated.
417/// `start_shape_id` is the starting shape ID (usually 1025).
418/// Returns the VML XML string.
419pub 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        // Skip controls whose cell reference cannot be resolved (e.g. data
430        // from a corrupted file). Validated controls added via
431        // add_form_control will never hit this branch.
432        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    // Form control shapetype (t201).
456    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
471/// Write a single VML form control shape element.
472fn 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    // x:ClientData element with control-specific properties.
549    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    // 3D shading: default is true for most controls. Write NoThreeD only when explicitly false.
591    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
600/// Parse form controls from a VML drawing XML string.
601///
602/// Scans for `<x:ClientData ObjectType="...">` elements and extracts
603/// control properties. Returns a list of FormControlInfo.
604pub 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        // Skip non-form-control shapes (e.g. comment shapes use ObjectType="Note").
617        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
626/// Parse form controls into the complete configuration needed for regeneration.
627pub(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
653/// Parse a single v:shape element into a FormControlInfo, if it is a form control.
654fn parse_single_control(shape_xml: &str) -> Option<FormControlInfo> {
655    // Find the ClientData element.
656    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    // Extract ObjectType attribute.
663    let obj_type = extract_attr(cd_xml, "ObjectType")?;
664    let control_type = FormControlType::from_object_type(&obj_type)?;
665
666    // Skip Note types (comments).
667    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
701/// Extract an XML attribute value from a tag.
702fn 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
710/// Extract text content of an XML element like `<tag>content</tag>`.
711fn 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
725/// Extract textbox text from a v:shape element.
726fn 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    // Text is inside a <div> or <font> element; extract plain text.
732    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
750/// Extract the anchor cell reference from x:Anchor element.
751///
752/// The anchor format is "col1, col1Off, row1, row1Off, col2, col2Off, row2, row2Off".
753/// We derive the cell from col1 (0-based) and row1 (0-based).
754fn 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
787/// Merge new form control VML into existing VML bytes (for sheets that
788/// already have VML content from comments or other controls).
789///
790/// This appends new shape elements before the closing `</xml>` tag and
791/// updates the shapetype if needed.
792pub 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    // Generate shape elements for the new controls.
800    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    // Check if the form control shapetype already exists.
813    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    // Insert before closing </xml>.
828    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        // Malformed VML; return new VML document.
838        build_form_control_vml(controls, start_shape_id).into_bytes()
839    }
840}
841
842impl FormControlInfo {
843    /// Convert a parsed `FormControlInfo` back to a `FormControlConfig`.
844    ///
845    /// This is used during VML hydration to reconstruct the config list from
846    /// existing VML data so that subsequent add/delete operations work correctly.
847    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
867/// Count existing VML shapes in VML bytes to determine the next shape ID.
868pub 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
873/// Return an unused VML shape ID after all existing shape IDs.
874pub(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
946/// Strip form control shapes from VML bytes, keeping non-control shapes.
947///
948/// Returns `None` if no non-control shapes remain after stripping.
949pub 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    // Collect ranges of form control shapes to remove.
953    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    // Rebuild VML with only the comment shapes preserved.
977    // Find the header portion (everything before the first <v:shape).
978    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 &amp; B &lt; &quot;quoted&quot; &apos;text&apos; 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        // Build a VML that has both a comment (Note) and a form control.
1428        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        // Should not duplicate shapetype.
1457        let shapetype_count = merged_str.matches(FORM_CONTROL_SHAPETYPE_ID).count();
1458        // One in the shapetype definition and references in each shape = 1 (def) + 2 (refs)
1459        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        // Verify VML part exists in the ZIP.
1626        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        // Re-open and verify controls are preserved.
1637        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        // Step 1: Create with 2 controls.
1921        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        // Step 2: Open, add one, delete one, save.
1929        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        // Step 3: Re-open and verify.
1936        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        // Build VML with both a comment shape and a form control shape.
1995        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        // Open and trigger hydration via get_form_controls (read-only).
2037        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        // Save without adding or removing anything.
2042        wb2.save(&path2).unwrap();
2043
2044        // Re-open and verify no duplication.
2045        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        // Open, add a new control, save.
2076        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        // Re-open and verify exact expected count.
2082        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        // Open, hydrate via get_form_controls, save.
2120        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        // Re-open and verify no duplication of either comments or controls.
2128        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        // Run 3 open-hydrate-save cycles.
2162        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        // Open and save immediately without calling get_form_controls.
2198        let wb2 = Workbook::open_with_options(&path1, &opts).unwrap();
2199        wb2.save(&path2).unwrap();
2200
2201        // Re-open and verify controls are preserved without duplication.
2202        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}