Struct Sheet 

pub struct Sheet {

    pub name: String,
    pub rows: Vec<Row>,
    pub conditional_formatting_rules: Vec<ConditionalFormattingRule>,
    pub data_validation_rules: Vec<DataValidationRule>,
    pub merged_ranges: Vec<String>,
    pub column_settings: Vec<ColumnSetting>,
    pub auto_filter_range: Option<String>,
    pub freeze_panes: Option<FreezePane>,
    pub print_settings: PrintSettings,
    pub protection: Option<SheetProtection>,
    pub hyperlinks: Vec<CellHyperlink>,
    pub comments: Vec<CellComment>,
    pub table: Option<ExcelTable>,
    pub visibility: SheetVisibility,
    pub zoom_scale: Option<u32>,
    pub tab_color: Option<String>,
    pub show_grid_lines: Option<bool>,
    pub show_row_col_headers: Option<bool>,
    pub show_zeros: Option<bool>,
    pub right_to_left: Option<bool>,
    pub active_cell: Option<String>,
    pub default_column_width: Option<f64>,
    pub default_row_height: Option<f64>,
    pub row_breaks: Vec<u32>,
    pub column_breaks: Vec<u32>,
    pub scenarios: Vec<Scenario>,
    pub auto_filter_columns: Vec<AutoFilterColumn>,
    pub ignored_errors: Vec<IgnoredError>,
    pub protected_ranges: Vec<ProtectedRange>,
    pub sort_state: Option<SortState>,
    pub outline_summary_below: Option<bool>,
    pub outline_summary_right: Option<bool>,
    pub drawing: Option<SheetDrawing>,
}

A single worksheet (xl/worksheets/sheetN.xml, CT_Worksheet): a name (shown on Excel’s sheet tab) plus a sequence of rows.

Fields

name: String

This sheet’s name (<sheet name=".."> in xl/workbook.xml), shown on Excel’s own sheet tab. Excel itself limits this to 31 characters and disallows a handful of characters (: \ / ? * [ ]) — neither limit is enforced here, same “caller’s responsibility” posture as word-ooxml’s PageSetup.orientation not auto-swapping dimensions.

rows: Vec<Row>

The rows that make up this sheet’s data, in order. A row’s own 1-based row number (<row r="..">) is simply this row’s position in this Vec plus one — not a separate field — so there is no way to represent a sparse sheet (e.g. data starting at row 5 with rows 1-4 genuinely absent) when writing; reading back a sparse sheet from a real .xlsx still works (missing rows are filled in as empty), see reader.rs.

conditional_formatting_rules: Vec<ConditionalFormattingRule>

Conditional formatting rules applied to ranges of this sheet (<conditionalFormatting>/<cfRule>, CT_ConditionalFormatting/ CT_CfRule), in order. Each rule gets its own dedicated <conditionalFormatting> block when written (see writer.rs::write_conditional_formatting) — real Excel groups multiple rules sharing the same range under one block, but nothing in the schema requires it, so this crate doesn’t bother.

data_validation_rules: Vec<DataValidationRule>

Data validation rules applied to ranges of this sheet (<dataValidations>/<dataValidation>, CT_DataValidations/ CT_DataValidation), in order.

merged_ranges: Vec<String>

Merged cell ranges (<mergeCells>/<mergeCell>, CT_MergeCells), each written verbatim as a range reference (e.g. "A1:C1"). This crate does not validate that ranges don’t overlap or that only the top-left cell of a merged range carries a value (both are the caller’s responsibility, same posture as ConditionalFormattingRule::range/DataValidationRule::range).

column_settings: Vec<ColumnSetting>

Per-column width/visibility/outline settings (<cols>/<col>, CT_Cols/CT_Col). Each entry covers exactly one column (min == max in the written XML) — this crate doesn’t bother collapsing adjacent identical entries into a single <col min="1" max="3"../> range the way real Excel does, same “less compact but schema-valid” posture as ConditionalFormattingRule’s one-block-per-rule choice.

auto_filter_range: Option<String>

The autofilter range (<autoFilter ref="..">, CT_AutoFilter), if any. Only the dropdown-arrow range is modeled, not per-column filter criteria (CT_FilterColumn/CT_Filters) — out of scope.

freeze_panes: Option<FreezePane>

Frozen (or split) panes (<sheetView><pane../></sheetView>, CT_Pane), if any. Only “frozen” panes are modeled (the common case, e.g. freezing a header row/column), not “split” panes (a draggable divider with no scroll-locking) — CT_Pane’s state="split" variant is out of scope.

print_settings: PrintSettings

This sheet’s print/page-setup settings (print area, repeated rows/columns, page orientation, fit-to-page, header/footer text). PrintSettings::default() (everything None) writes no print-related XML at all.

protection: Option<SheetProtection>

This sheet’s protection settings (<sheetProtection>, CT_SheetProtection), if protected.

hyperlinks: Vec<CellHyperlink>

Per-cell hyperlinks (<hyperlinks>/<hyperlink>, CT_Hyperlinks/ CT_Hyperlink).

comments: Vec<CellComment>

Per-cell comments (legacy xl/comments*.xml + VML drawing, CT_Comments/CT_Comment).

table: Option<ExcelTable>

A structured (ListObject) table on this sheet (<tableParts>/<tablePart> + a dedicated xl/tables/tableN.xml part, CT_Table), if any. Only one table per sheet is modeled (this crate’s own scope choice, not an ECMA-376 limit — real Excel allows several) since a single example is enough to prove the feature out; a second table on the same sheet is simply never written.

visibility: SheetVisibility

This sheet’s tab visibility (<sheet state="."> in xl/workbook.xml — a CT_Sheet attribute, not part of the worksheet part itself) — extended to a genuine three-state SheetVisibility (was a plain bool before this).

zoom_scale: Option<u32>

This sheet’s own display zoom percentage (<sheetView zoomScale="..">, e.g. 100 for 100%). None leaves Excel’s own default (100%).

tab_color: Option<String>

This sheet’s tab color (<sheetPr><tabColor rgb=".."/></sheetPr>), as an 8-hex-digit ARGB string. None leaves Excel’s own default (no color, the plain gray/white tab).

show_grid_lines: Option<bool>

Whether this sheet’s view shows gridlines (<sheetView showGridLines="..">). None leaves Excel’s own default (shown).

show_row_col_headers: Option<bool>

Whether this sheet’s view shows row/column headers (<sheetView showRowColHeaders="..">). None leaves Excel’s own default (shown).

show_zeros: Option<bool>

Whether this sheet’s view shows zero values, or leaves those cells blank (<sheetView showZeros="..">). None leaves Excel’s own default (shown).

right_to_left: Option<bool>

Whether this sheet’s view is laid out right-to-left (<sheetView rightToLeft="..">). None leaves Excel’s own default (left-to-right).

active_cell: Option<String>

The cell selected/active when this sheet is shown (<selection activeCell=".." sqref="..">, both attributes written the same — this crate only models a single selected cell, not a multi-cell selection). Distinct from Workbook::active_tab: this is the cell selected within this sheet, not which sheet tab is shown. None leaves Excel’s own default (A1).

default_column_width: Option<f64>

This sheet’s default column width, in Excel’s own character-width units (<sheetFormatPr defaultColWidth="..">). Distinct from ColumnSetting::width: this is the width used for every column without its own explicit ColumnSetting. None leaves Excel’s own default.

default_row_height: Option<f64>

This sheet’s default row height, in points (<sheetFormatPr defaultRowHeight="..">). Distinct from Row::height: this is the height used for every row without its own explicit height. None leaves Excel’s own default (15, i.e. defaultRowHeight is always written with a concrete value — CT_SheetFormatPr::defaultRowHeight is mandatory whenever <sheetFormatPr> is written at all, unlike every other field on this type).

row_breaks: Vec<u32>

Manual page breaks after these 1-based row numbers (<rowBreaks>/<brk>, CT_PageBreak).

column_breaks: Vec<u32>

Manual page breaks after these 1-based column numbers (<colBreaks>/<brk>).

scenarios: Vec<Scenario>

“What-if” scenarios (<scenarios>/<scenario>, CT_Scenario).

auto_filter_columns: Vec<AutoFilterColumn>

Per-column filter criteria for auto_filter_range (<filterColumn>/<filters>, CT_FilterColumn/CT_Filters). A no-op if auto_filter_range is None. Only the simplest form (a fixed list of checked/visible values) is modeled — CT_Filters’s custom criteria, top10, and date-grouping filter forms are not.

ignored_errors: Vec<IgnoredError>

Suppressed error-checking indicators (the little green triangle in a cell’s corner and its “Ignore Error” right-click option), (<ignoredErrors>/<ignoredError>, CT_IgnoredErrors/ CT_IgnoredError). Each entry covers one range and one or more error categories; this crate writes one <ignoredError> element per IgnoredError entry, same “less compact but schema-valid” posture as ColumnSetting/ ConditionalFormattingRule not bothering to merge adjacent/ overlapping ranges the way real Excel’s UI sometimes does.

protected_ranges: Vec<ProtectedRange>

Multiple named protected ranges (<protectedRanges>/ <protectedRange>, CT_ProtectedRanges/CT_ProtectedRange). Distinct from Sheet::protection (point 13, <sheetProtection>): that locks/unlocks editing for the whole sheet at once (based on each cell’s own locked CellFormat flag), while this is Excel’s older “Allow Users to Edit Ranges” feature — one or more named ranges, each optionally its own password, that stay editable while the rest of a protected sheet is locked. CT_Worksheet’s sequence puts protectedRanges right after sheetProtection, before scenarios (confirmed via sml.xsd).

sort_state: Option<SortState>

A remembered sort order for auto_filter_range (<autoFilter><sortState>..</sortState></autoFilter>). A no-op if auto_filter_range is None (same posture as auto_filter_columns). CT_AutoFilter’s own sequence puts sortState after filterColumn*, nested inside <autoFilter> — distinct from ExcelTable::sort_state, which is a sibling of a table’s own <autoFilter>, not a child of it (see that field’s doc comment for the schema source).

outline_summary_below: Option<bool>

Whether an outline/grouping’s summary rows sit below their detail rows, or above (<sheetPr><outlinePr summaryBelow="..">, CT_SheetPr/CT_OutlinePr). Relevant only when Row::outline_level/column grouping is used. None leaves Excel’s own default (true, summary below); Some(false) matches the “summary above” layout common in accounting templates. Confirmed via sml.xsd: outlinePr is CT_SheetPr’s second child, right after tabColor?.

outline_summary_right: Option<bool>

Whether an outline/grouping’s summary columns sit to the right of their detail columns, or to the left (<outlinePr summaryRight="..">) — same point 55, the column-axis counterpart of outline_summary_below. None leaves Excel’s own default (true, summary to the right).

drawing: Option<SheetDrawing>

This sheet’s DrawingML drawing — embedded pictures and/or charts, each anchored to a cell range (<drawing r:id=".."> referencing a dedicated xl/drawings/drawingN.xml part, CT_Drawing/xdr:wsDr). Only one drawing part per sheet is modeled (this crate’s own scope choice, not an ECMA-376 limit — real Excel only ever has one anyway), same posture as Sheet::table. None writes no <drawing> element and no drawing part at all.

Implementations

impl Sheet

pub fn new(name: impl Into<String>) -> Sheet

Creates an empty sheet (no rows) with the given name.

Examples found in repository

examples/hello_world_xlsx.rs (line 19)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("hello_world.xlsx");

    // `Workbook` and `Row` both come from `office_toolkit::prelude`.
    // `Row::with_text` puts a single text cell in column A.
    let workbook = Workbook::new()
        .with_sheet(Sheet::new("Sheet1").with_row(Row::new().with_text("Hello, world!")));
    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());

    // Read the file back to confirm it is a valid .xlsx.
    let reopened = Workbook::open_file(&path)?;
    let cell_a1 = &reopened.sheets[0].rows[0].cells[0].value;
    println!("Read back A1: {cell_a1:?}");
    assert!(matches!(cell_a1, CellValue::Text(text) if text == "Hello, world!"));

    Ok(())
}

examples/xlsx_images_and_charts.rs (line 26)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_images_and_charts.xlsx");
    let image_bytes = std::fs::read(image_fixture_path())?;

    let picture = SheetPicture::new(image_bytes, PictureFormat::Png).with_name("Test image");
    let picture_sheet = Sheet::new("Picture")
        .with_row(Row::new().with_text("The picture is anchored to cell A1:"))
        .with_drawing(SheetDrawing::new().with_anchor(DrawingAnchor::new(
            CellAnchorPoint::new(0, 1),
            CellAnchorPoint::new(2, 6),
            DrawingObject::Picture(Box::new(picture)),
        )));

    let chart = SheetChart::new(sample_chart_space()).with_name("Quarterly revenue");
    let chart_sheet = Sheet::new("Chart")
        .with_row(Row::new().with_text("A bar chart is anchored below:"))
        .with_drawing(SheetDrawing::new().with_anchor(DrawingAnchor::new(
            CellAnchorPoint::new(0, 1),
            CellAnchorPoint::new(6, 16),
            DrawingObject::Chart(Box::new(chart)),
        )));

    let workbook = Workbook::new()
        .with_sheet(picture_sheet)
        .with_sheet(chart_sheet);
    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

examples/xlsx_protection.rs (line 19)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_protection.xlsx");

    let sheet_protection_sheet = Sheet::new("Sheet protection")
        .with_row(Row::new().with_text("Locked: this sheet is protected with a password."))
        .with_protection(SheetProtection::with_password("secret"));

    let protected_range_sheet = Sheet::new("Protected range")
        .with_row(
            Row::new()
                .with_text("A1 is protected; B1 stays editable via a named unprotected range."),
        )
        .with_protection(SheetProtection::locked())
        .with_protected_range(ProtectedRange::new("EditableArea", "B1:B1").with_password("secret"));

    let workbook = Workbook::new()
        .with_write_protection(
            WriteProtection::recommended()
                .with_user_name("Author")
                .with_password("secret"),
        )
        .with_sheet(sheet_protection_sheet)
        .with_sheet(protected_range_sheet);

    // `Workbook.protection` (structure protection: locking sheet
    // add/rename/hide/reorder/delete) has no `with_*` builder — it's set
    // directly, like any other public field.
    let workbook = Workbook {
        protection: Some(WorkbookProtection::locked().with_lock_windows(true)),
        ..workbook
    };

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

examples/xlsx_print_and_views.rs (line 17)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_print_and_views.xlsx");

    let print_setup_sheet = Sheet::new("Print setup")
        .with_row(Row::new().with_text("Header").with_text("Header"))
        .with_row(Row::new().with_text("Data").with_number(1.0))
        .with_print_settings(
            PrintSettings::new()
                .with_print_area("A1:B2")
                .with_repeat_rows("1:1")
                .with_fit_to_width(1)
                .with_fit_to_height(0)
                .with_scale(100)
                .with_orientation(PageOrientation::Landscape)
                .with_header("&CCompany Report")
                .with_footer("&LPage &P of &N"),
        );

    let view_options_sheet = Sheet::new("View options")
        .with_row(Row::new().with_text("Zoomed, colored tab, no gridlines"))
        .with_zoom_scale(150)
        .with_tab_color("FFC00000")
        .with_show_grid_lines(false)
        .with_show_row_col_headers(false)
        .with_show_zeros(false)
        .with_right_to_left(false)
        .with_active_cell("A1")
        .with_default_column_width(12.0)
        .with_default_row_height(18.0);

    let hidden_sheet = Sheet::new("Hidden sheet")
        .with_row(Row::new().with_text("Not shown in the tab bar unless unhidden."))
        .with_visibility(SheetVisibility::Hidden);

    let workbook = Workbook::new()
        .with_sheet(print_setup_sheet)
        .with_sheet(view_options_sheet)
        .with_sheet(hidden_sheet);

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

examples/xlsx_structure_and_layout.rs (line 16)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_structure_and_layout.xlsx");

    let merged_sheet = Sheet::new("Merged cells")
        .with_row(Row::new().with_text("This title spans three columns"))
        .with_merged_range("A1:C1");

    let columns_sheet = Sheet::new("Columns")
        .with_row(
            Row::new()
                .with_cell(Cell::text("Wide"))
                .with_cell(Cell::text("Hidden"))
                .with_cell(Cell::text("Grouped")),
        )
        .with_column_setting(ColumnSetting::new(0).with_width(30.0))
        .with_column_setting(ColumnSetting::new(1).with_hidden(true))
        .with_column_setting(
            ColumnSetting::new(2)
                .with_outline_level(1)
                .with_collapsed(false),
        );

    let rows_sheet = Sheet::new("Rows")
        .with_row(Row::new().with_text("Normal row"))
        .with_row(Row::new().with_text("Taller row").with_height(30.0))
        .with_row(Row::new().with_text("Hidden row").with_hidden(true))
        .with_row(
            Row::new()
                .with_text("Grouped detail row")
                .with_outline_level(1),
        );

    let frozen_panes_sheet = Sheet::new("Frozen panes")
        .with_row(
            Row::new()
                .with_cell(Cell::text("Frozen header"))
                .with_cell(Cell::text("Frozen header")),
        )
        .with_row(
            Row::new()
                .with_cell(Cell::text("Scrolling data"))
                .with_cell(Cell::number(1.0)),
        )
        .with_freeze_panes(FreezePane::new(1, 1));

    let page_breaks_sheet = Sheet::new("Page breaks")
        .with_row(Row::new().with_text("Above this row: page break"))
        .with_row(Row::new().with_text("Below the break"))
        .with_row_break(1)
        .with_column_break(0)
        .with_outline_summary_below(false)
        .with_outline_summary_right(false);

    let workbook = Workbook::new()
        .with_sheet(merged_sheet)
        .with_sheet(columns_sheet)
        .with_sheet(rows_sheet)
        .with_sheet(frozen_panes_sheet)
        .with_sheet(page_breaks_sheet);

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

examples/xlsx_workbook_metadata.rs (line 19)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_workbook_metadata.xlsx");

    let named_ranges_sheet = Sheet::new("Named ranges")
        .with_row(Row::new().with_text("Tax rate").with_number(0.0825))
        .with_row(Row::new().with_cell(Cell::formula("TaxRate*100").with_cached_value(8.25)));

    let calculation_sheet = Sheet::new("Calculation").with_row(
        Row::new().with_text("Set to manual recalculation with iterative calculation enabled."),
    );

    let scenarios_sheet = Sheet::new("Scenarios")
        .with_row(Row::new().with_text("Revenue").with_number(100_000.0))
        .with_row(Row::new().with_text("Cost").with_number(60_000.0))
        .with_scenario(
            Scenario::new("Best case")
                .with_input("B1", "150000")
                .with_input("B2", "55000")
                .with_comment("Optimistic projection"),
        )
        .with_scenario(
            Scenario::new("Worst case")
                .with_input("B1", "70000")
                .with_input("B2", "65000"),
        );

    let auto_filter_sheet = Sheet::new("Autofilter criteria")
        .with_row(Row::new().with_text("Region"))
        .with_row(Row::new().with_text("North"))
        .with_row(Row::new().with_text("South"))
        .with_auto_filter_range("A1:A3")
        .with_auto_filter_column(AutoFilterColumn::new(0, vec!["North".to_string()]));

    let ignored_errors_sheet = Sheet::new("Ignored errors")
        .with_row(Row::new().with_text("123")) // a number stored as text — normally flagged by Excel
        .with_ignored_error(IgnoredError::new("A1:A1").with_number_stored_as_text(true));

    let workbook = Workbook::new()
        .with_defined_name(DefinedName::new("TaxRate", "'Named ranges'!$B$1"))
        .with_calculation(
            CalculationProperties::new()
                .with_mode(CalculationMode::Manual)
                .with_iterate(true),
        )
        .with_sheet(named_ranges_sheet)
        .with_sheet(calculation_sheet)
        .with_sheet(scenarios_sheet)
        .with_sheet(auto_filter_sheet)
        .with_sheet(ignored_errors_sheet);

    // `Workbook.properties` has no `with_*` builder — it's set directly,
    // like any other public field.
    let properties = DocumentProperties::new()
        .with_title("Metadata example")
        .with_author("Example Author")
        .with_subject("Workbook-level features")
        .with_custom_property(
            "ProjectCode",
            CustomPropertyValue::Text("XLSX-META".to_string()),
        );
    let workbook = Workbook {
        properties,
        ..workbook
    };

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

Additional examples can be found in:

• examples/xlsx_tables.rs
• examples/xlsx_conditional_formatting_and_validation.rs
• examples/xlsx_rich_data.rs
• examples/xlsx_cell_formatting.rs

pub fn with_row(self, row: Row) -> Sheet

Appends a row and returns the sheet for chaining.

Examples found in repository

examples/hello_world_xlsx.rs (line 19)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("hello_world.xlsx");

    // `Workbook` and `Row` both come from `office_toolkit::prelude`.
    // `Row::with_text` puts a single text cell in column A.
    let workbook = Workbook::new()
        .with_sheet(Sheet::new("Sheet1").with_row(Row::new().with_text("Hello, world!")));
    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());

    // Read the file back to confirm it is a valid .xlsx.
    let reopened = Workbook::open_file(&path)?;
    let cell_a1 = &reopened.sheets[0].rows[0].cells[0].value;
    println!("Read back A1: {cell_a1:?}");
    assert!(matches!(cell_a1, CellValue::Text(text) if text == "Hello, world!"));

    Ok(())
}

examples/xlsx_images_and_charts.rs (line 27)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_images_and_charts.xlsx");
    let image_bytes = std::fs::read(image_fixture_path())?;

    let picture = SheetPicture::new(image_bytes, PictureFormat::Png).with_name("Test image");
    let picture_sheet = Sheet::new("Picture")
        .with_row(Row::new().with_text("The picture is anchored to cell A1:"))
        .with_drawing(SheetDrawing::new().with_anchor(DrawingAnchor::new(
            CellAnchorPoint::new(0, 1),
            CellAnchorPoint::new(2, 6),
            DrawingObject::Picture(Box::new(picture)),
        )));

    let chart = SheetChart::new(sample_chart_space()).with_name("Quarterly revenue");
    let chart_sheet = Sheet::new("Chart")
        .with_row(Row::new().with_text("A bar chart is anchored below:"))
        .with_drawing(SheetDrawing::new().with_anchor(DrawingAnchor::new(
            CellAnchorPoint::new(0, 1),
            CellAnchorPoint::new(6, 16),
            DrawingObject::Chart(Box::new(chart)),
        )));

    let workbook = Workbook::new()
        .with_sheet(picture_sheet)
        .with_sheet(chart_sheet);
    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

examples/xlsx_protection.rs (line 20)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_protection.xlsx");

    let sheet_protection_sheet = Sheet::new("Sheet protection")
        .with_row(Row::new().with_text("Locked: this sheet is protected with a password."))
        .with_protection(SheetProtection::with_password("secret"));

    let protected_range_sheet = Sheet::new("Protected range")
        .with_row(
            Row::new()
                .with_text("A1 is protected; B1 stays editable via a named unprotected range."),
        )
        .with_protection(SheetProtection::locked())
        .with_protected_range(ProtectedRange::new("EditableArea", "B1:B1").with_password("secret"));

    let workbook = Workbook::new()
        .with_write_protection(
            WriteProtection::recommended()
                .with_user_name("Author")
                .with_password("secret"),
        )
        .with_sheet(sheet_protection_sheet)
        .with_sheet(protected_range_sheet);

    // `Workbook.protection` (structure protection: locking sheet
    // add/rename/hide/reorder/delete) has no `with_*` builder — it's set
    // directly, like any other public field.
    let workbook = Workbook {
        protection: Some(WorkbookProtection::locked().with_lock_windows(true)),
        ..workbook
    };

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

examples/xlsx_print_and_views.rs (line 18)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_print_and_views.xlsx");

    let print_setup_sheet = Sheet::new("Print setup")
        .with_row(Row::new().with_text("Header").with_text("Header"))
        .with_row(Row::new().with_text("Data").with_number(1.0))
        .with_print_settings(
            PrintSettings::new()
                .with_print_area("A1:B2")
                .with_repeat_rows("1:1")
                .with_fit_to_width(1)
                .with_fit_to_height(0)
                .with_scale(100)
                .with_orientation(PageOrientation::Landscape)
                .with_header("&CCompany Report")
                .with_footer("&LPage &P of &N"),
        );

    let view_options_sheet = Sheet::new("View options")
        .with_row(Row::new().with_text("Zoomed, colored tab, no gridlines"))
        .with_zoom_scale(150)
        .with_tab_color("FFC00000")
        .with_show_grid_lines(false)
        .with_show_row_col_headers(false)
        .with_show_zeros(false)
        .with_right_to_left(false)
        .with_active_cell("A1")
        .with_default_column_width(12.0)
        .with_default_row_height(18.0);

    let hidden_sheet = Sheet::new("Hidden sheet")
        .with_row(Row::new().with_text("Not shown in the tab bar unless unhidden."))
        .with_visibility(SheetVisibility::Hidden);

    let workbook = Workbook::new()
        .with_sheet(print_setup_sheet)
        .with_sheet(view_options_sheet)
        .with_sheet(hidden_sheet);

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

examples/xlsx_structure_and_layout.rs (line 17)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_structure_and_layout.xlsx");

    let merged_sheet = Sheet::new("Merged cells")
        .with_row(Row::new().with_text("This title spans three columns"))
        .with_merged_range("A1:C1");

    let columns_sheet = Sheet::new("Columns")
        .with_row(
            Row::new()
                .with_cell(Cell::text("Wide"))
                .with_cell(Cell::text("Hidden"))
                .with_cell(Cell::text("Grouped")),
        )
        .with_column_setting(ColumnSetting::new(0).with_width(30.0))
        .with_column_setting(ColumnSetting::new(1).with_hidden(true))
        .with_column_setting(
            ColumnSetting::new(2)
                .with_outline_level(1)
                .with_collapsed(false),
        );

    let rows_sheet = Sheet::new("Rows")
        .with_row(Row::new().with_text("Normal row"))
        .with_row(Row::new().with_text("Taller row").with_height(30.0))
        .with_row(Row::new().with_text("Hidden row").with_hidden(true))
        .with_row(
            Row::new()
                .with_text("Grouped detail row")
                .with_outline_level(1),
        );

    let frozen_panes_sheet = Sheet::new("Frozen panes")
        .with_row(
            Row::new()
                .with_cell(Cell::text("Frozen header"))
                .with_cell(Cell::text("Frozen header")),
        )
        .with_row(
            Row::new()
                .with_cell(Cell::text("Scrolling data"))
                .with_cell(Cell::number(1.0)),
        )
        .with_freeze_panes(FreezePane::new(1, 1));

    let page_breaks_sheet = Sheet::new("Page breaks")
        .with_row(Row::new().with_text("Above this row: page break"))
        .with_row(Row::new().with_text("Below the break"))
        .with_row_break(1)
        .with_column_break(0)
        .with_outline_summary_below(false)
        .with_outline_summary_right(false);

    let workbook = Workbook::new()
        .with_sheet(merged_sheet)
        .with_sheet(columns_sheet)
        .with_sheet(rows_sheet)
        .with_sheet(frozen_panes_sheet)
        .with_sheet(page_breaks_sheet);

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

examples/xlsx_workbook_metadata.rs (line 20)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_workbook_metadata.xlsx");

    let named_ranges_sheet = Sheet::new("Named ranges")
        .with_row(Row::new().with_text("Tax rate").with_number(0.0825))
        .with_row(Row::new().with_cell(Cell::formula("TaxRate*100").with_cached_value(8.25)));

    let calculation_sheet = Sheet::new("Calculation").with_row(
        Row::new().with_text("Set to manual recalculation with iterative calculation enabled."),
    );

    let scenarios_sheet = Sheet::new("Scenarios")
        .with_row(Row::new().with_text("Revenue").with_number(100_000.0))
        .with_row(Row::new().with_text("Cost").with_number(60_000.0))
        .with_scenario(
            Scenario::new("Best case")
                .with_input("B1", "150000")
                .with_input("B2", "55000")
                .with_comment("Optimistic projection"),
        )
        .with_scenario(
            Scenario::new("Worst case")
                .with_input("B1", "70000")
                .with_input("B2", "65000"),
        );

    let auto_filter_sheet = Sheet::new("Autofilter criteria")
        .with_row(Row::new().with_text("Region"))
        .with_row(Row::new().with_text("North"))
        .with_row(Row::new().with_text("South"))
        .with_auto_filter_range("A1:A3")
        .with_auto_filter_column(AutoFilterColumn::new(0, vec!["North".to_string()]));

    let ignored_errors_sheet = Sheet::new("Ignored errors")
        .with_row(Row::new().with_text("123")) // a number stored as text — normally flagged by Excel
        .with_ignored_error(IgnoredError::new("A1:A1").with_number_stored_as_text(true));

    let workbook = Workbook::new()
        .with_defined_name(DefinedName::new("TaxRate", "'Named ranges'!$B$1"))
        .with_calculation(
            CalculationProperties::new()
                .with_mode(CalculationMode::Manual)
                .with_iterate(true),
        )
        .with_sheet(named_ranges_sheet)
        .with_sheet(calculation_sheet)
        .with_sheet(scenarios_sheet)
        .with_sheet(auto_filter_sheet)
        .with_sheet(ignored_errors_sheet);

    // `Workbook.properties` has no `with_*` builder — it's set directly,
    // like any other public field.
    let properties = DocumentProperties::new()
        .with_title("Metadata example")
        .with_author("Example Author")
        .with_subject("Workbook-level features")
        .with_custom_property(
            "ProjectCode",
            CustomPropertyValue::Text("XLSX-META".to_string()),
        );
    let workbook = Workbook {
        properties,
        ..workbook
    };

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

Additional examples can be found in:

• examples/xlsx_tables.rs
• examples/xlsx_conditional_formatting_and_validation.rs
• examples/xlsx_rich_data.rs
• examples/xlsx_cell_formatting.rs

pub fn write_cell( &mut self, row: u32, col: u32, cell: impl Into<Cell>, ) -> &mut Cell

Writes cell at the given 1-based (row, col) position — (1, 1) is A1 — growing rows and the target row’s own cells with empty padding cells as needed to reach it, and returns a mutable reference to the cell just written. Direct coordinate addressing, for the common case of writing cells out of strict top-to-bottom, left-to-right order (or just one cell at a time in a loop) without assembling a full Row by hand first. 1-based, to match this crate’s own existing convention — a row’s or cell’s position in its Vec plus one (see Sheet::rows’s and Row::cells’s doc comments) — so a Sheet never mixes two different numbering schemes depending on which method touched it.

Padding cells are genuinely empty (Cell::new/Cell::default), not written out as <c> elements at all unless later given a format — same posture as a sparse Row built by hand.

Accepts anything convertible to a Cell — a Cell itself (built via Cell::text/Cell::formula/Cell::date/etc. for the cases below that need one made explicitly), or, for the three unambiguous cases, the raw value directly: &str/String (→ CellValue::Text), f64 (→ CellValue::Number), bool (→ CellValue::Boolean) — the common case a caller writing cells one at a time reaches for most often. Formulas, dates, rich text, and array formulas are deliberately not covered by an automatic conversion — there’s no unambiguous way to tell “this is a formula” from a plain string, or “this number is a date” from a plain number, so those still go through their own Cell::* constructor.

Panics

Panics if row or col is 0 (1-based, so 0 is never a valid position).

pub fn with_conditional_formatting_rule( self, rule: ConditionalFormattingRule, ) -> Sheet

Appends a conditional formatting rule and returns the sheet for chaining.

Examples found in repository

examples/xlsx_conditional_formatting_and_validation.rs (lines 24-31)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_conditional_formatting_and_validation.xlsx");

    let cell_is_sheet = Sheet::new("Cell-is rule")
        .with_row(Row::new().with_number(45.0))
        .with_row(Row::new().with_number(72.0))
        .with_row(Row::new().with_number(91.0))
        .with_conditional_formatting_rule(ConditionalFormattingRule::cell_is(
            "A1:A3",
            ComparisonOperator::GreaterThan,
            "70",
            CellFormat::new()
                .with_fill_color("FFC6EFCE")
                .with_font_color("FF006100"),
        ));

    let scales_and_bars_sheet = Sheet::new("Color scale and data bar")
        .with_row(Row::new().with_number(10.0))
        .with_row(Row::new().with_number(50.0))
        .with_row(Row::new().with_number(90.0))
        .with_conditional_formatting_rule(ConditionalFormattingRule::color_scale(
            "A1:A3",
            vec![
                ColorScaleStop::new(CfvoPosition::Min, "FFF8696B"),
                ColorScaleStop::new(CfvoPosition::Max, "FF63BE7B"),
            ],
        ))
        .with_row(Row::new().with_number(10.0))
        .with_row(Row::new().with_number(50.0))
        .with_row(Row::new().with_number(90.0))
        .with_conditional_formatting_rule(ConditionalFormattingRule::data_bar(
            "B1:B3",
            CfvoPosition::Min,
            CfvoPosition::Max,
            "FF638EC6",
        ));

    let icon_set_and_ranking_sheet = Sheet::new("Icon set, top-10, duplicates")
        .with_row(Row::new().with_number(1.0))
        .with_row(Row::new().with_number(2.0))
        .with_row(Row::new().with_number(3.0))
        .with_conditional_formatting_rule(ConditionalFormattingRule::icon_set(
            "A1:A3",
            IconSetType::ThreeTrafficLights,
        ))
        .with_row(Row::new().with_number(4.0))
        .with_row(Row::new().with_number(5.0))
        .with_row(Row::new().with_number(6.0))
        .with_conditional_formatting_rule(ConditionalFormattingRule::top10(
            "B1:B3",
            1,
            false,
            CellFormat::new().with_bold(true),
        ))
        .with_row(Row::new().with_text("A"))
        .with_row(Row::new().with_text("A"))
        .with_row(Row::new().with_text("B"))
        .with_conditional_formatting_rule(ConditionalFormattingRule::duplicate_values(
            "C1:C3",
            CellFormat::new().with_fill_color("FFFFC7CE"),
        ));

    let data_validation_sheet = Sheet::new("Data validation")
        .with_row(Row::new().with_text("Pick one"))
        .with_data_validation_rule(DataValidationRule::list("A1:A1", "\"Small,Medium,Large\""))
        .with_row(Row::new().with_number(0.0))
        .with_data_validation_rule(
            DataValidationRule::whole_number("B1:B1", ComparisonOperator::LessThanOrEqual, "100")
                .with_input_message(
                    Message::new("Enter a whole number from 0 to 100.").with_title("Valid range"),
                )
                .with_error_message(
                    Message::new("That value is out of range.").with_title("Invalid entry"),
                ),
        );

    let workbook = Workbook::new()
        .with_sheet(cell_is_sheet)
        .with_sheet(scales_and_bars_sheet)
        .with_sheet(icon_set_and_ranking_sheet)
        .with_sheet(data_validation_sheet);

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

pub fn with_data_validation_rule(self, rule: DataValidationRule) -> Sheet

Appends a data validation rule and returns the sheet for chaining.

Examples found in repository

examples/xlsx_conditional_formatting_and_validation.rs (line 81)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_conditional_formatting_and_validation.xlsx");

    let cell_is_sheet = Sheet::new("Cell-is rule")
        .with_row(Row::new().with_number(45.0))
        .with_row(Row::new().with_number(72.0))
        .with_row(Row::new().with_number(91.0))
        .with_conditional_formatting_rule(ConditionalFormattingRule::cell_is(
            "A1:A3",
            ComparisonOperator::GreaterThan,
            "70",
            CellFormat::new()
                .with_fill_color("FFC6EFCE")
                .with_font_color("FF006100"),
        ));

    let scales_and_bars_sheet = Sheet::new("Color scale and data bar")
        .with_row(Row::new().with_number(10.0))
        .with_row(Row::new().with_number(50.0))
        .with_row(Row::new().with_number(90.0))
        .with_conditional_formatting_rule(ConditionalFormattingRule::color_scale(
            "A1:A3",
            vec![
                ColorScaleStop::new(CfvoPosition::Min, "FFF8696B"),
                ColorScaleStop::new(CfvoPosition::Max, "FF63BE7B"),
            ],
        ))
        .with_row(Row::new().with_number(10.0))
        .with_row(Row::new().with_number(50.0))
        .with_row(Row::new().with_number(90.0))
        .with_conditional_formatting_rule(ConditionalFormattingRule::data_bar(
            "B1:B3",
            CfvoPosition::Min,
            CfvoPosition::Max,
            "FF638EC6",
        ));

    let icon_set_and_ranking_sheet = Sheet::new("Icon set, top-10, duplicates")
        .with_row(Row::new().with_number(1.0))
        .with_row(Row::new().with_number(2.0))
        .with_row(Row::new().with_number(3.0))
        .with_conditional_formatting_rule(ConditionalFormattingRule::icon_set(
            "A1:A3",
            IconSetType::ThreeTrafficLights,
        ))
        .with_row(Row::new().with_number(4.0))
        .with_row(Row::new().with_number(5.0))
        .with_row(Row::new().with_number(6.0))
        .with_conditional_formatting_rule(ConditionalFormattingRule::top10(
            "B1:B3",
            1,
            false,
            CellFormat::new().with_bold(true),
        ))
        .with_row(Row::new().with_text("A"))
        .with_row(Row::new().with_text("A"))
        .with_row(Row::new().with_text("B"))
        .with_conditional_formatting_rule(ConditionalFormattingRule::duplicate_values(
            "C1:C3",
            CellFormat::new().with_fill_color("FFFFC7CE"),
        ));

    let data_validation_sheet = Sheet::new("Data validation")
        .with_row(Row::new().with_text("Pick one"))
        .with_data_validation_rule(DataValidationRule::list("A1:A1", "\"Small,Medium,Large\""))
        .with_row(Row::new().with_number(0.0))
        .with_data_validation_rule(
            DataValidationRule::whole_number("B1:B1", ComparisonOperator::LessThanOrEqual, "100")
                .with_input_message(
                    Message::new("Enter a whole number from 0 to 100.").with_title("Valid range"),
                )
                .with_error_message(
                    Message::new("That value is out of range.").with_title("Invalid entry"),
                ),
        );

    let workbook = Workbook::new()
        .with_sheet(cell_is_sheet)
        .with_sheet(scales_and_bars_sheet)
        .with_sheet(icon_set_and_ranking_sheet)
        .with_sheet(data_validation_sheet);

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

pub fn with_merged_range(self, range: impl Into<String>) -> Sheet

Appends a merged cell range (e.g. "A1:C1") and returns the sheet for chaining.

Examples found in repository

examples/xlsx_structure_and_layout.rs (line 18)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_structure_and_layout.xlsx");

    let merged_sheet = Sheet::new("Merged cells")
        .with_row(Row::new().with_text("This title spans three columns"))
        .with_merged_range("A1:C1");

    let columns_sheet = Sheet::new("Columns")
        .with_row(
            Row::new()
                .with_cell(Cell::text("Wide"))
                .with_cell(Cell::text("Hidden"))
                .with_cell(Cell::text("Grouped")),
        )
        .with_column_setting(ColumnSetting::new(0).with_width(30.0))
        .with_column_setting(ColumnSetting::new(1).with_hidden(true))
        .with_column_setting(
            ColumnSetting::new(2)
                .with_outline_level(1)
                .with_collapsed(false),
        );

    let rows_sheet = Sheet::new("Rows")
        .with_row(Row::new().with_text("Normal row"))
        .with_row(Row::new().with_text("Taller row").with_height(30.0))
        .with_row(Row::new().with_text("Hidden row").with_hidden(true))
        .with_row(
            Row::new()
                .with_text("Grouped detail row")
                .with_outline_level(1),
        );

    let frozen_panes_sheet = Sheet::new("Frozen panes")
        .with_row(
            Row::new()
                .with_cell(Cell::text("Frozen header"))
                .with_cell(Cell::text("Frozen header")),
        )
        .with_row(
            Row::new()
                .with_cell(Cell::text("Scrolling data"))
                .with_cell(Cell::number(1.0)),
        )
        .with_freeze_panes(FreezePane::new(1, 1));

    let page_breaks_sheet = Sheet::new("Page breaks")
        .with_row(Row::new().with_text("Above this row: page break"))
        .with_row(Row::new().with_text("Below the break"))
        .with_row_break(1)
        .with_column_break(0)
        .with_outline_summary_below(false)
        .with_outline_summary_right(false);

    let workbook = Workbook::new()
        .with_sheet(merged_sheet)
        .with_sheet(columns_sheet)
        .with_sheet(rows_sheet)
        .with_sheet(frozen_panes_sheet)
        .with_sheet(page_breaks_sheet);

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

pub fn with_column_setting(self, setting: ColumnSetting) -> Sheet

Appends a column setting and returns the sheet for chaining.

Examples found in repository

examples/xlsx_structure_and_layout.rs (line 27)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_structure_and_layout.xlsx");

    let merged_sheet = Sheet::new("Merged cells")
        .with_row(Row::new().with_text("This title spans three columns"))
        .with_merged_range("A1:C1");

    let columns_sheet = Sheet::new("Columns")
        .with_row(
            Row::new()
                .with_cell(Cell::text("Wide"))
                .with_cell(Cell::text("Hidden"))
                .with_cell(Cell::text("Grouped")),
        )
        .with_column_setting(ColumnSetting::new(0).with_width(30.0))
        .with_column_setting(ColumnSetting::new(1).with_hidden(true))
        .with_column_setting(
            ColumnSetting::new(2)
                .with_outline_level(1)
                .with_collapsed(false),
        );

    let rows_sheet = Sheet::new("Rows")
        .with_row(Row::new().with_text("Normal row"))
        .with_row(Row::new().with_text("Taller row").with_height(30.0))
        .with_row(Row::new().with_text("Hidden row").with_hidden(true))
        .with_row(
            Row::new()
                .with_text("Grouped detail row")
                .with_outline_level(1),
        );

    let frozen_panes_sheet = Sheet::new("Frozen panes")
        .with_row(
            Row::new()
                .with_cell(Cell::text("Frozen header"))
                .with_cell(Cell::text("Frozen header")),
        )
        .with_row(
            Row::new()
                .with_cell(Cell::text("Scrolling data"))
                .with_cell(Cell::number(1.0)),
        )
        .with_freeze_panes(FreezePane::new(1, 1));

    let page_breaks_sheet = Sheet::new("Page breaks")
        .with_row(Row::new().with_text("Above this row: page break"))
        .with_row(Row::new().with_text("Below the break"))
        .with_row_break(1)
        .with_column_break(0)
        .with_outline_summary_below(false)
        .with_outline_summary_right(false);

    let workbook = Workbook::new()
        .with_sheet(merged_sheet)
        .with_sheet(columns_sheet)
        .with_sheet(rows_sheet)
        .with_sheet(frozen_panes_sheet)
        .with_sheet(page_breaks_sheet);

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

pub fn with_auto_filter_range(self, range: impl Into<String>) -> Sheet

Sets the autofilter range and returns the sheet for chaining.

Examples found in repository

examples/xlsx_workbook_metadata.rs (line 46)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_workbook_metadata.xlsx");

    let named_ranges_sheet = Sheet::new("Named ranges")
        .with_row(Row::new().with_text("Tax rate").with_number(0.0825))
        .with_row(Row::new().with_cell(Cell::formula("TaxRate*100").with_cached_value(8.25)));

    let calculation_sheet = Sheet::new("Calculation").with_row(
        Row::new().with_text("Set to manual recalculation with iterative calculation enabled."),
    );

    let scenarios_sheet = Sheet::new("Scenarios")
        .with_row(Row::new().with_text("Revenue").with_number(100_000.0))
        .with_row(Row::new().with_text("Cost").with_number(60_000.0))
        .with_scenario(
            Scenario::new("Best case")
                .with_input("B1", "150000")
                .with_input("B2", "55000")
                .with_comment("Optimistic projection"),
        )
        .with_scenario(
            Scenario::new("Worst case")
                .with_input("B1", "70000")
                .with_input("B2", "65000"),
        );

    let auto_filter_sheet = Sheet::new("Autofilter criteria")
        .with_row(Row::new().with_text("Region"))
        .with_row(Row::new().with_text("North"))
        .with_row(Row::new().with_text("South"))
        .with_auto_filter_range("A1:A3")
        .with_auto_filter_column(AutoFilterColumn::new(0, vec!["North".to_string()]));

    let ignored_errors_sheet = Sheet::new("Ignored errors")
        .with_row(Row::new().with_text("123")) // a number stored as text — normally flagged by Excel
        .with_ignored_error(IgnoredError::new("A1:A1").with_number_stored_as_text(true));

    let workbook = Workbook::new()
        .with_defined_name(DefinedName::new("TaxRate", "'Named ranges'!$B$1"))
        .with_calculation(
            CalculationProperties::new()
                .with_mode(CalculationMode::Manual)
                .with_iterate(true),
        )
        .with_sheet(named_ranges_sheet)
        .with_sheet(calculation_sheet)
        .with_sheet(scenarios_sheet)
        .with_sheet(auto_filter_sheet)
        .with_sheet(ignored_errors_sheet);

    // `Workbook.properties` has no `with_*` builder — it's set directly,
    // like any other public field.
    let properties = DocumentProperties::new()
        .with_title("Metadata example")
        .with_author("Example Author")
        .with_subject("Workbook-level features")
        .with_custom_property(
            "ProjectCode",
            CustomPropertyValue::Text("XLSX-META".to_string()),
        );
    let workbook = Workbook {
        properties,
        ..workbook
    };

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

pub fn with_freeze_panes(self, freeze_panes: FreezePane) -> Sheet

Sets frozen panes and returns the sheet for chaining.

Examples found in repository

examples/xlsx_structure_and_layout.rs (line 56)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_structure_and_layout.xlsx");

    let merged_sheet = Sheet::new("Merged cells")
        .with_row(Row::new().with_text("This title spans three columns"))
        .with_merged_range("A1:C1");

    let columns_sheet = Sheet::new("Columns")
        .with_row(
            Row::new()
                .with_cell(Cell::text("Wide"))
                .with_cell(Cell::text("Hidden"))
                .with_cell(Cell::text("Grouped")),
        )
        .with_column_setting(ColumnSetting::new(0).with_width(30.0))
        .with_column_setting(ColumnSetting::new(1).with_hidden(true))
        .with_column_setting(
            ColumnSetting::new(2)
                .with_outline_level(1)
                .with_collapsed(false),
        );

    let rows_sheet = Sheet::new("Rows")
        .with_row(Row::new().with_text("Normal row"))
        .with_row(Row::new().with_text("Taller row").with_height(30.0))
        .with_row(Row::new().with_text("Hidden row").with_hidden(true))
        .with_row(
            Row::new()
                .with_text("Grouped detail row")
                .with_outline_level(1),
        );

    let frozen_panes_sheet = Sheet::new("Frozen panes")
        .with_row(
            Row::new()
                .with_cell(Cell::text("Frozen header"))
                .with_cell(Cell::text("Frozen header")),
        )
        .with_row(
            Row::new()
                .with_cell(Cell::text("Scrolling data"))
                .with_cell(Cell::number(1.0)),
        )
        .with_freeze_panes(FreezePane::new(1, 1));

    let page_breaks_sheet = Sheet::new("Page breaks")
        .with_row(Row::new().with_text("Above this row: page break"))
        .with_row(Row::new().with_text("Below the break"))
        .with_row_break(1)
        .with_column_break(0)
        .with_outline_summary_below(false)
        .with_outline_summary_right(false);

    let workbook = Workbook::new()
        .with_sheet(merged_sheet)
        .with_sheet(columns_sheet)
        .with_sheet(rows_sheet)
        .with_sheet(frozen_panes_sheet)
        .with_sheet(page_breaks_sheet);

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

pub fn with_print_settings(self, print_settings: PrintSettings) -> Sheet

Sets this sheet’s print settings and returns the sheet for chaining.

Examples found in repository

examples/xlsx_print_and_views.rs (lines 20-30)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_print_and_views.xlsx");

    let print_setup_sheet = Sheet::new("Print setup")
        .with_row(Row::new().with_text("Header").with_text("Header"))
        .with_row(Row::new().with_text("Data").with_number(1.0))
        .with_print_settings(
            PrintSettings::new()
                .with_print_area("A1:B2")
                .with_repeat_rows("1:1")
                .with_fit_to_width(1)
                .with_fit_to_height(0)
                .with_scale(100)
                .with_orientation(PageOrientation::Landscape)
                .with_header("&CCompany Report")
                .with_footer("&LPage &P of &N"),
        );

    let view_options_sheet = Sheet::new("View options")
        .with_row(Row::new().with_text("Zoomed, colored tab, no gridlines"))
        .with_zoom_scale(150)
        .with_tab_color("FFC00000")
        .with_show_grid_lines(false)
        .with_show_row_col_headers(false)
        .with_show_zeros(false)
        .with_right_to_left(false)
        .with_active_cell("A1")
        .with_default_column_width(12.0)
        .with_default_row_height(18.0);

    let hidden_sheet = Sheet::new("Hidden sheet")
        .with_row(Row::new().with_text("Not shown in the tab bar unless unhidden."))
        .with_visibility(SheetVisibility::Hidden);

    let workbook = Workbook::new()
        .with_sheet(print_setup_sheet)
        .with_sheet(view_options_sheet)
        .with_sheet(hidden_sheet);

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

pub fn with_protection(self, protection: SheetProtection) -> Sheet

Sets this sheet’s protection and returns the sheet for chaining.

Examples found in repository

examples/xlsx_protection.rs (line 21)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_protection.xlsx");

    let sheet_protection_sheet = Sheet::new("Sheet protection")
        .with_row(Row::new().with_text("Locked: this sheet is protected with a password."))
        .with_protection(SheetProtection::with_password("secret"));

    let protected_range_sheet = Sheet::new("Protected range")
        .with_row(
            Row::new()
                .with_text("A1 is protected; B1 stays editable via a named unprotected range."),
        )
        .with_protection(SheetProtection::locked())
        .with_protected_range(ProtectedRange::new("EditableArea", "B1:B1").with_password("secret"));

    let workbook = Workbook::new()
        .with_write_protection(
            WriteProtection::recommended()
                .with_user_name("Author")
                .with_password("secret"),
        )
        .with_sheet(sheet_protection_sheet)
        .with_sheet(protected_range_sheet);

    // `Workbook.protection` (structure protection: locking sheet
    // add/rename/hide/reorder/delete) has no `with_*` builder — it's set
    // directly, like any other public field.
    let workbook = Workbook {
        protection: Some(WorkbookProtection::locked().with_lock_windows(true)),
        ..workbook
    };

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

pub fn with_hyperlink(self, hyperlink: CellHyperlink) -> Sheet

Appends a cell hyperlink and returns the sheet for chaining.

Examples found in repository

examples/xlsx_rich_data.rs (lines 70-73)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_rich_data.xlsx");

    let dates_and_booleans_sheet = Sheet::new("Dates and booleans")
        .with_row(Row::new().with_cell(Cell::date(ExcelDateTime::date(2026, 7, 21))))
        .with_row(Row::new().with_cell(Cell::date(
            ExcelDateTime::date(2026, 7, 21).with_time(14, 30, 0),
        )))
        .with_row(
            Row::new()
                .with_cell(Cell::boolean(true))
                .with_cell(Cell::boolean(false)),
        );

    // An array/shared formula's `ref` must be a range whose top-left cell
    // is the cell the `<f t="array"|"shared">` element actually sits in —
    // `with_cell` fills a row left-to-right starting at column A, so each
    // formula cell below is positioned to land exactly on its own `ref`'s
    // first cell, with plain cached-value cells (no `<f>`) filling out the
    // rest of the declared range, matching how Excel itself writes a
    // multi-cell array/shared formula. The previous version declared
    // ranges like "D1:D3"/"E1:E3" while the formula cells actually landed
    // in column A — a real cell/range mismatch Excel refuses to open
    // without repairing.
    let formulas_sheet = Sheet::new("Formulas")
        .with_row(
            Row::new()
                .with_cell(Cell::number(10.0))
                .with_cell(Cell::number(20.0))
                .with_cell(Cell::formula("A1+B1").with_cached_value(30.0)),
        )
        .with_row(
            Row::new()
                .with_cell(Cell::array_formula("A1:A3*2", "A2:C2").with_cached_value(20.0))
                .with_cell(Cell::number(40.0))
                .with_cell(Cell::number(60.0)),
        )
        .with_row(
            Row::new()
                .with_cell(Cell::shared_formula("A1+1", 0, "A3:C3").with_cached_value(11.0))
                .with_cell(Cell::shared_formula_follower(0).with_cached_value(21.0))
                .with_cell(Cell::shared_formula_follower(0).with_cached_value(31.0)),
        );

    let rich_text_sheet =
        Sheet::new("Rich text").with_row(Row::new().with_cell(Cell::rich_text(vec![
        RichTextRun::new("Bold red, ").with_bold(true).with_font_color("FFC00000"),
        RichTextRun::new("then italic blue.").with_italic(true).with_font_color("FF2E74B5"),
    ])));

    let hyperlinks_sheet = Sheet::new("Hyperlinks")
        .with_row(
            Row::new()
                .with_text("Visit Rust")
                .with_text("Jump to C1")
                .with_text("You've arrived"),
        )
        .with_hyperlink(
            CellHyperlink::external("A1", "https://www.rust-lang.org")
                .with_tooltip("Opens in your browser"),
        )
        .with_hyperlink(CellHyperlink::internal("B1", "'Hyperlinks'!C1"));

    let comments_sheet = Sheet::new("Comments")
        .with_row(
            Row::new()
                .with_text("Hover B1 for a comment")
                .with_text("Reviewed"),
        )
        .with_comment(CellComment::new(
            "A1",
            "Reviewer",
            "Double-check this figure before publishing.",
        ))
        .with_comment(
            CellComment::new("B1", "Reviewer", "Looks correct.")
                .with_rich_text(vec![RichTextRun::new("Looks correct.").with_bold(true)]),
        );

    let workbook = Workbook::new()
        .with_sheet(dates_and_booleans_sheet)
        .with_sheet(formulas_sheet)
        .with_sheet(rich_text_sheet)
        .with_sheet(hyperlinks_sheet)
        .with_sheet(comments_sheet);

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

pub fn with_comment(self, comment: CellComment) -> Sheet

Appends a cell comment and returns the sheet for chaining.

Examples found in repository

examples/xlsx_rich_data.rs (lines 82-86)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_rich_data.xlsx");

    let dates_and_booleans_sheet = Sheet::new("Dates and booleans")
        .with_row(Row::new().with_cell(Cell::date(ExcelDateTime::date(2026, 7, 21))))
        .with_row(Row::new().with_cell(Cell::date(
            ExcelDateTime::date(2026, 7, 21).with_time(14, 30, 0),
        )))
        .with_row(
            Row::new()
                .with_cell(Cell::boolean(true))
                .with_cell(Cell::boolean(false)),
        );

    // An array/shared formula's `ref` must be a range whose top-left cell
    // is the cell the `<f t="array"|"shared">` element actually sits in —
    // `with_cell` fills a row left-to-right starting at column A, so each
    // formula cell below is positioned to land exactly on its own `ref`'s
    // first cell, with plain cached-value cells (no `<f>`) filling out the
    // rest of the declared range, matching how Excel itself writes a
    // multi-cell array/shared formula. The previous version declared
    // ranges like "D1:D3"/"E1:E3" while the formula cells actually landed
    // in column A — a real cell/range mismatch Excel refuses to open
    // without repairing.
    let formulas_sheet = Sheet::new("Formulas")
        .with_row(
            Row::new()
                .with_cell(Cell::number(10.0))
                .with_cell(Cell::number(20.0))
                .with_cell(Cell::formula("A1+B1").with_cached_value(30.0)),
        )
        .with_row(
            Row::new()
                .with_cell(Cell::array_formula("A1:A3*2", "A2:C2").with_cached_value(20.0))
                .with_cell(Cell::number(40.0))
                .with_cell(Cell::number(60.0)),
        )
        .with_row(
            Row::new()
                .with_cell(Cell::shared_formula("A1+1", 0, "A3:C3").with_cached_value(11.0))
                .with_cell(Cell::shared_formula_follower(0).with_cached_value(21.0))
                .with_cell(Cell::shared_formula_follower(0).with_cached_value(31.0)),
        );

    let rich_text_sheet =
        Sheet::new("Rich text").with_row(Row::new().with_cell(Cell::rich_text(vec![
        RichTextRun::new("Bold red, ").with_bold(true).with_font_color("FFC00000"),
        RichTextRun::new("then italic blue.").with_italic(true).with_font_color("FF2E74B5"),
    ])));

    let hyperlinks_sheet = Sheet::new("Hyperlinks")
        .with_row(
            Row::new()
                .with_text("Visit Rust")
                .with_text("Jump to C1")
                .with_text("You've arrived"),
        )
        .with_hyperlink(
            CellHyperlink::external("A1", "https://www.rust-lang.org")
                .with_tooltip("Opens in your browser"),
        )
        .with_hyperlink(CellHyperlink::internal("B1", "'Hyperlinks'!C1"));

    let comments_sheet = Sheet::new("Comments")
        .with_row(
            Row::new()
                .with_text("Hover B1 for a comment")
                .with_text("Reviewed"),
        )
        .with_comment(CellComment::new(
            "A1",
            "Reviewer",
            "Double-check this figure before publishing.",
        ))
        .with_comment(
            CellComment::new("B1", "Reviewer", "Looks correct.")
                .with_rich_text(vec![RichTextRun::new("Looks correct.").with_bold(true)]),
        );

    let workbook = Workbook::new()
        .with_sheet(dates_and_booleans_sheet)
        .with_sheet(formulas_sheet)
        .with_sheet(rich_text_sheet)
        .with_sheet(hyperlinks_sheet)
        .with_sheet(comments_sheet);

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

pub fn with_table(self, table: ExcelTable) -> Sheet

Sets this sheet’s structured table and returns the sheet for chaining.

Examples found in repository

examples/xlsx_tables.rs (lines 23-27)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_tables.xlsx");

    let plain_sheet = Sheet::new("Plain table")
        .with_row(Row::new().with_text("Name").with_text("Score"))
        .with_row(Row::new().with_text("Alice").with_number(92.0))
        .with_row(Row::new().with_text("Bob").with_number(87.0))
        .with_table(ExcelTable::new(
            "ScoresTable",
            "A1:B3",
            vec!["Name", "Score"],
        ));

    let calculated_sheet = Sheet::new("Calculated and totals")
        .with_row(
            Row::new()
                .with_text("Item")
                .with_text("Qty")
                .with_text("Unit price")
                .with_text("Line total"),
        )
        .with_row(
            Row::new()
                .with_text("Widget")
                .with_number(3.0)
                .with_number(9.99)
                .with_cell(Cell::formula("B2*C2").with_cached_value(29.97)),
        )
        .with_row(
            Row::new()
                .with_text("Gadget")
                .with_number(2.0)
                .with_number(19.99)
                .with_cell(Cell::formula("B3*C3").with_cached_value(39.98)),
        )
        .with_row(Row::new().with_cell(Cell::text("Total")))
        .with_table(
            ExcelTable::with_columns(
                "OrdersTable",
                "A1:D4",
                vec![
                    TableColumn::new("Item"),
                    TableColumn::new("Qty").with_totals_row_function(TotalsRowFunction::Sum),
                    TableColumn::new("Unit price"),
                    TableColumn::new("Line total")
                        .with_calculated_formula(
                            "OrdersTable[[#This Row],[Qty]]*OrdersTable[[#This Row],[Unit price]]",
                        )
                        .with_totals_row_function(TotalsRowFunction::Sum),
                ],
            )
            .with_totals_row(true),
        );

    let styled_sheet = Sheet::new("Custom style and sort")
        .with_row(Row::new().with_text("City").with_text("Population"))
        .with_row(Row::new().with_text("Springfield").with_number(120_000.0))
        .with_row(Row::new().with_text("Shelbyville").with_number(95_000.0))
        .with_table(
            ExcelTable::new("CitiesTable", "A1:B3", vec!["City", "Population"])
                .with_table_style_name("CustomTableStyle")
                .with_sort_state(
                    SortState::new("A2:B3")
                        .with_condition(SortCondition::new("B2:B3").with_descending(true)),
                ),
        );

    let workbook = Workbook::new()
        .with_table_style(
            TableStyle::new("CustomTableStyle")
                .with_element(TableStyleElement::new(
                    TableStyleElementType::HeaderRow,
                    CellFormat::new()
                        .with_bold(true)
                        .with_fill_color("FF2E74B5")
                        .with_font_color("FFFFFFFF"),
                ))
                .with_element(TableStyleElement::new(
                    TableStyleElementType::FirstRowStripe,
                    CellFormat::new().with_fill_color("FFF2F2F2"),
                )),
        )
        .with_sheet(plain_sheet)
        .with_sheet(calculated_sheet)
        .with_sheet(styled_sheet);

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

pub fn with_drawing(self, drawing: SheetDrawing) -> Sheet

Sets this sheet’s drawing (embedded pictures/charts) and returns the sheet for chaining.

Examples found in repository

examples/xlsx_images_and_charts.rs (lines 28-32)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_images_and_charts.xlsx");
    let image_bytes = std::fs::read(image_fixture_path())?;

    let picture = SheetPicture::new(image_bytes, PictureFormat::Png).with_name("Test image");
    let picture_sheet = Sheet::new("Picture")
        .with_row(Row::new().with_text("The picture is anchored to cell A1:"))
        .with_drawing(SheetDrawing::new().with_anchor(DrawingAnchor::new(
            CellAnchorPoint::new(0, 1),
            CellAnchorPoint::new(2, 6),
            DrawingObject::Picture(Box::new(picture)),
        )));

    let chart = SheetChart::new(sample_chart_space()).with_name("Quarterly revenue");
    let chart_sheet = Sheet::new("Chart")
        .with_row(Row::new().with_text("A bar chart is anchored below:"))
        .with_drawing(SheetDrawing::new().with_anchor(DrawingAnchor::new(
            CellAnchorPoint::new(0, 1),
            CellAnchorPoint::new(6, 16),
            DrawingObject::Chart(Box::new(chart)),
        )));

    let workbook = Workbook::new()
        .with_sheet(picture_sheet)
        .with_sheet(chart_sheet);
    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

pub fn with_visibility(self, visibility: SheetVisibility) -> Sheet

Sets this sheet’s tab visibility and returns the sheet for chaining — replacing the old with_hidden(bool) (removed, pre-1.0 breaking change): use with_visibility(SheetVisibility::Hidden) for what used to be with_hidden(true).

Examples found in repository

examples/xlsx_print_and_views.rs (line 46)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_print_and_views.xlsx");

    let print_setup_sheet = Sheet::new("Print setup")
        .with_row(Row::new().with_text("Header").with_text("Header"))
        .with_row(Row::new().with_text("Data").with_number(1.0))
        .with_print_settings(
            PrintSettings::new()
                .with_print_area("A1:B2")
                .with_repeat_rows("1:1")
                .with_fit_to_width(1)
                .with_fit_to_height(0)
                .with_scale(100)
                .with_orientation(PageOrientation::Landscape)
                .with_header("&CCompany Report")
                .with_footer("&LPage &P of &N"),
        );

    let view_options_sheet = Sheet::new("View options")
        .with_row(Row::new().with_text("Zoomed, colored tab, no gridlines"))
        .with_zoom_scale(150)
        .with_tab_color("FFC00000")
        .with_show_grid_lines(false)
        .with_show_row_col_headers(false)
        .with_show_zeros(false)
        .with_right_to_left(false)
        .with_active_cell("A1")
        .with_default_column_width(12.0)
        .with_default_row_height(18.0);

    let hidden_sheet = Sheet::new("Hidden sheet")
        .with_row(Row::new().with_text("Not shown in the tab bar unless unhidden."))
        .with_visibility(SheetVisibility::Hidden);

    let workbook = Workbook::new()
        .with_sheet(print_setup_sheet)
        .with_sheet(view_options_sheet)
        .with_sheet(hidden_sheet);

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

pub fn with_zoom_scale(self, zoom_scale: u32) -> Sheet

Sets this sheet’s display zoom percentage and returns the sheet for chaining.

Examples found in repository

examples/xlsx_print_and_views.rs (line 34)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_print_and_views.xlsx");

    let print_setup_sheet = Sheet::new("Print setup")
        .with_row(Row::new().with_text("Header").with_text("Header"))
        .with_row(Row::new().with_text("Data").with_number(1.0))
        .with_print_settings(
            PrintSettings::new()
                .with_print_area("A1:B2")
                .with_repeat_rows("1:1")
                .with_fit_to_width(1)
                .with_fit_to_height(0)
                .with_scale(100)
                .with_orientation(PageOrientation::Landscape)
                .with_header("&CCompany Report")
                .with_footer("&LPage &P of &N"),
        );

    let view_options_sheet = Sheet::new("View options")
        .with_row(Row::new().with_text("Zoomed, colored tab, no gridlines"))
        .with_zoom_scale(150)
        .with_tab_color("FFC00000")
        .with_show_grid_lines(false)
        .with_show_row_col_headers(false)
        .with_show_zeros(false)
        .with_right_to_left(false)
        .with_active_cell("A1")
        .with_default_column_width(12.0)
        .with_default_row_height(18.0);

    let hidden_sheet = Sheet::new("Hidden sheet")
        .with_row(Row::new().with_text("Not shown in the tab bar unless unhidden."))
        .with_visibility(SheetVisibility::Hidden);

    let workbook = Workbook::new()
        .with_sheet(print_setup_sheet)
        .with_sheet(view_options_sheet)
        .with_sheet(hidden_sheet);

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

pub fn with_tab_color(self, color: impl Into<String>) -> Sheet

Sets this sheet’s tab color (8-hex-digit ARGB) and returns the sheet for chaining.

Examples found in repository

examples/xlsx_print_and_views.rs (line 35)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_print_and_views.xlsx");

    let print_setup_sheet = Sheet::new("Print setup")
        .with_row(Row::new().with_text("Header").with_text("Header"))
        .with_row(Row::new().with_text("Data").with_number(1.0))
        .with_print_settings(
            PrintSettings::new()
                .with_print_area("A1:B2")
                .with_repeat_rows("1:1")
                .with_fit_to_width(1)
                .with_fit_to_height(0)
                .with_scale(100)
                .with_orientation(PageOrientation::Landscape)
                .with_header("&CCompany Report")
                .with_footer("&LPage &P of &N"),
        );

    let view_options_sheet = Sheet::new("View options")
        .with_row(Row::new().with_text("Zoomed, colored tab, no gridlines"))
        .with_zoom_scale(150)
        .with_tab_color("FFC00000")
        .with_show_grid_lines(false)
        .with_show_row_col_headers(false)
        .with_show_zeros(false)
        .with_right_to_left(false)
        .with_active_cell("A1")
        .with_default_column_width(12.0)
        .with_default_row_height(18.0);

    let hidden_sheet = Sheet::new("Hidden sheet")
        .with_row(Row::new().with_text("Not shown in the tab bar unless unhidden."))
        .with_visibility(SheetVisibility::Hidden);

    let workbook = Workbook::new()
        .with_sheet(print_setup_sheet)
        .with_sheet(view_options_sheet)
        .with_sheet(hidden_sheet);

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

pub fn with_show_grid_lines(self, show: bool) -> Sheet

Sets whether this sheet’s view shows gridlines and returns the sheet for chaining.

Examples found in repository

examples/xlsx_print_and_views.rs (line 36)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_print_and_views.xlsx");

    let print_setup_sheet = Sheet::new("Print setup")
        .with_row(Row::new().with_text("Header").with_text("Header"))
        .with_row(Row::new().with_text("Data").with_number(1.0))
        .with_print_settings(
            PrintSettings::new()
                .with_print_area("A1:B2")
                .with_repeat_rows("1:1")
                .with_fit_to_width(1)
                .with_fit_to_height(0)
                .with_scale(100)
                .with_orientation(PageOrientation::Landscape)
                .with_header("&CCompany Report")
                .with_footer("&LPage &P of &N"),
        );

    let view_options_sheet = Sheet::new("View options")
        .with_row(Row::new().with_text("Zoomed, colored tab, no gridlines"))
        .with_zoom_scale(150)
        .with_tab_color("FFC00000")
        .with_show_grid_lines(false)
        .with_show_row_col_headers(false)
        .with_show_zeros(false)
        .with_right_to_left(false)
        .with_active_cell("A1")
        .with_default_column_width(12.0)
        .with_default_row_height(18.0);

    let hidden_sheet = Sheet::new("Hidden sheet")
        .with_row(Row::new().with_text("Not shown in the tab bar unless unhidden."))
        .with_visibility(SheetVisibility::Hidden);

    let workbook = Workbook::new()
        .with_sheet(print_setup_sheet)
        .with_sheet(view_options_sheet)
        .with_sheet(hidden_sheet);

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

pub fn with_show_row_col_headers(self, show: bool) -> Sheet

Sets whether this sheet’s view shows row/column headers and returns the sheet for chaining.

Examples found in repository

examples/xlsx_print_and_views.rs (line 37)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_print_and_views.xlsx");

    let print_setup_sheet = Sheet::new("Print setup")
        .with_row(Row::new().with_text("Header").with_text("Header"))
        .with_row(Row::new().with_text("Data").with_number(1.0))
        .with_print_settings(
            PrintSettings::new()
                .with_print_area("A1:B2")
                .with_repeat_rows("1:1")
                .with_fit_to_width(1)
                .with_fit_to_height(0)
                .with_scale(100)
                .with_orientation(PageOrientation::Landscape)
                .with_header("&CCompany Report")
                .with_footer("&LPage &P of &N"),
        );

    let view_options_sheet = Sheet::new("View options")
        .with_row(Row::new().with_text("Zoomed, colored tab, no gridlines"))
        .with_zoom_scale(150)
        .with_tab_color("FFC00000")
        .with_show_grid_lines(false)
        .with_show_row_col_headers(false)
        .with_show_zeros(false)
        .with_right_to_left(false)
        .with_active_cell("A1")
        .with_default_column_width(12.0)
        .with_default_row_height(18.0);

    let hidden_sheet = Sheet::new("Hidden sheet")
        .with_row(Row::new().with_text("Not shown in the tab bar unless unhidden."))
        .with_visibility(SheetVisibility::Hidden);

    let workbook = Workbook::new()
        .with_sheet(print_setup_sheet)
        .with_sheet(view_options_sheet)
        .with_sheet(hidden_sheet);

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

pub fn with_show_zeros(self, show: bool) -> Sheet

Sets whether this sheet’s view shows zero values and returns the sheet for chaining.

Examples found in repository

examples/xlsx_print_and_views.rs (line 38)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_print_and_views.xlsx");

    let print_setup_sheet = Sheet::new("Print setup")
        .with_row(Row::new().with_text("Header").with_text("Header"))
        .with_row(Row::new().with_text("Data").with_number(1.0))
        .with_print_settings(
            PrintSettings::new()
                .with_print_area("A1:B2")
                .with_repeat_rows("1:1")
                .with_fit_to_width(1)
                .with_fit_to_height(0)
                .with_scale(100)
                .with_orientation(PageOrientation::Landscape)
                .with_header("&CCompany Report")
                .with_footer("&LPage &P of &N"),
        );

    let view_options_sheet = Sheet::new("View options")
        .with_row(Row::new().with_text("Zoomed, colored tab, no gridlines"))
        .with_zoom_scale(150)
        .with_tab_color("FFC00000")
        .with_show_grid_lines(false)
        .with_show_row_col_headers(false)
        .with_show_zeros(false)
        .with_right_to_left(false)
        .with_active_cell("A1")
        .with_default_column_width(12.0)
        .with_default_row_height(18.0);

    let hidden_sheet = Sheet::new("Hidden sheet")
        .with_row(Row::new().with_text("Not shown in the tab bar unless unhidden."))
        .with_visibility(SheetVisibility::Hidden);

    let workbook = Workbook::new()
        .with_sheet(print_setup_sheet)
        .with_sheet(view_options_sheet)
        .with_sheet(hidden_sheet);

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

pub fn with_right_to_left(self, right_to_left: bool) -> Sheet

Sets whether this sheet’s view is laid out right-to-left and returns the sheet for chaining.

Examples found in repository

examples/xlsx_print_and_views.rs (line 39)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_print_and_views.xlsx");

    let print_setup_sheet = Sheet::new("Print setup")
        .with_row(Row::new().with_text("Header").with_text("Header"))
        .with_row(Row::new().with_text("Data").with_number(1.0))
        .with_print_settings(
            PrintSettings::new()
                .with_print_area("A1:B2")
                .with_repeat_rows("1:1")
                .with_fit_to_width(1)
                .with_fit_to_height(0)
                .with_scale(100)
                .with_orientation(PageOrientation::Landscape)
                .with_header("&CCompany Report")
                .with_footer("&LPage &P of &N"),
        );

    let view_options_sheet = Sheet::new("View options")
        .with_row(Row::new().with_text("Zoomed, colored tab, no gridlines"))
        .with_zoom_scale(150)
        .with_tab_color("FFC00000")
        .with_show_grid_lines(false)
        .with_show_row_col_headers(false)
        .with_show_zeros(false)
        .with_right_to_left(false)
        .with_active_cell("A1")
        .with_default_column_width(12.0)
        .with_default_row_height(18.0);

    let hidden_sheet = Sheet::new("Hidden sheet")
        .with_row(Row::new().with_text("Not shown in the tab bar unless unhidden."))
        .with_visibility(SheetVisibility::Hidden);

    let workbook = Workbook::new()
        .with_sheet(print_setup_sheet)
        .with_sheet(view_options_sheet)
        .with_sheet(hidden_sheet);

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

pub fn with_active_cell(self, cell: impl Into<String>) -> Sheet

Sets the cell selected/active when this sheet is shown (e.g. "B3") and returns the sheet for chaining.

Examples found in repository

examples/xlsx_print_and_views.rs (line 40)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_print_and_views.xlsx");

    let print_setup_sheet = Sheet::new("Print setup")
        .with_row(Row::new().with_text("Header").with_text("Header"))
        .with_row(Row::new().with_text("Data").with_number(1.0))
        .with_print_settings(
            PrintSettings::new()
                .with_print_area("A1:B2")
                .with_repeat_rows("1:1")
                .with_fit_to_width(1)
                .with_fit_to_height(0)
                .with_scale(100)
                .with_orientation(PageOrientation::Landscape)
                .with_header("&CCompany Report")
                .with_footer("&LPage &P of &N"),
        );

    let view_options_sheet = Sheet::new("View options")
        .with_row(Row::new().with_text("Zoomed, colored tab, no gridlines"))
        .with_zoom_scale(150)
        .with_tab_color("FFC00000")
        .with_show_grid_lines(false)
        .with_show_row_col_headers(false)
        .with_show_zeros(false)
        .with_right_to_left(false)
        .with_active_cell("A1")
        .with_default_column_width(12.0)
        .with_default_row_height(18.0);

    let hidden_sheet = Sheet::new("Hidden sheet")
        .with_row(Row::new().with_text("Not shown in the tab bar unless unhidden."))
        .with_visibility(SheetVisibility::Hidden);

    let workbook = Workbook::new()
        .with_sheet(print_setup_sheet)
        .with_sheet(view_options_sheet)
        .with_sheet(hidden_sheet);

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

pub fn with_default_column_width(self, width: f64) -> Sheet

Sets this sheet’s default column width and returns the sheet for chaining.

Examples found in repository

examples/xlsx_print_and_views.rs (line 41)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_print_and_views.xlsx");

    let print_setup_sheet = Sheet::new("Print setup")
        .with_row(Row::new().with_text("Header").with_text("Header"))
        .with_row(Row::new().with_text("Data").with_number(1.0))
        .with_print_settings(
            PrintSettings::new()
                .with_print_area("A1:B2")
                .with_repeat_rows("1:1")
                .with_fit_to_width(1)
                .with_fit_to_height(0)
                .with_scale(100)
                .with_orientation(PageOrientation::Landscape)
                .with_header("&CCompany Report")
                .with_footer("&LPage &P of &N"),
        );

    let view_options_sheet = Sheet::new("View options")
        .with_row(Row::new().with_text("Zoomed, colored tab, no gridlines"))
        .with_zoom_scale(150)
        .with_tab_color("FFC00000")
        .with_show_grid_lines(false)
        .with_show_row_col_headers(false)
        .with_show_zeros(false)
        .with_right_to_left(false)
        .with_active_cell("A1")
        .with_default_column_width(12.0)
        .with_default_row_height(18.0);

    let hidden_sheet = Sheet::new("Hidden sheet")
        .with_row(Row::new().with_text("Not shown in the tab bar unless unhidden."))
        .with_visibility(SheetVisibility::Hidden);

    let workbook = Workbook::new()
        .with_sheet(print_setup_sheet)
        .with_sheet(view_options_sheet)
        .with_sheet(hidden_sheet);

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

pub fn with_default_row_height(self, height: f64) -> Sheet

Sets this sheet’s default row height and returns the sheet for chaining.

Examples found in repository

examples/xlsx_print_and_views.rs (line 42)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_print_and_views.xlsx");

    let print_setup_sheet = Sheet::new("Print setup")
        .with_row(Row::new().with_text("Header").with_text("Header"))
        .with_row(Row::new().with_text("Data").with_number(1.0))
        .with_print_settings(
            PrintSettings::new()
                .with_print_area("A1:B2")
                .with_repeat_rows("1:1")
                .with_fit_to_width(1)
                .with_fit_to_height(0)
                .with_scale(100)
                .with_orientation(PageOrientation::Landscape)
                .with_header("&CCompany Report")
                .with_footer("&LPage &P of &N"),
        );

    let view_options_sheet = Sheet::new("View options")
        .with_row(Row::new().with_text("Zoomed, colored tab, no gridlines"))
        .with_zoom_scale(150)
        .with_tab_color("FFC00000")
        .with_show_grid_lines(false)
        .with_show_row_col_headers(false)
        .with_show_zeros(false)
        .with_right_to_left(false)
        .with_active_cell("A1")
        .with_default_column_width(12.0)
        .with_default_row_height(18.0);

    let hidden_sheet = Sheet::new("Hidden sheet")
        .with_row(Row::new().with_text("Not shown in the tab bar unless unhidden."))
        .with_visibility(SheetVisibility::Hidden);

    let workbook = Workbook::new()
        .with_sheet(print_setup_sheet)
        .with_sheet(view_options_sheet)
        .with_sheet(hidden_sheet);

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

pub fn with_row_break(self, row: u32) -> Sheet

Adds a manual page break after the given 1-based row number and returns the sheet for chaining.

Examples found in repository

examples/xlsx_structure_and_layout.rs (line 61)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_structure_and_layout.xlsx");

    let merged_sheet = Sheet::new("Merged cells")
        .with_row(Row::new().with_text("This title spans three columns"))
        .with_merged_range("A1:C1");

    let columns_sheet = Sheet::new("Columns")
        .with_row(
            Row::new()
                .with_cell(Cell::text("Wide"))
                .with_cell(Cell::text("Hidden"))
                .with_cell(Cell::text("Grouped")),
        )
        .with_column_setting(ColumnSetting::new(0).with_width(30.0))
        .with_column_setting(ColumnSetting::new(1).with_hidden(true))
        .with_column_setting(
            ColumnSetting::new(2)
                .with_outline_level(1)
                .with_collapsed(false),
        );

    let rows_sheet = Sheet::new("Rows")
        .with_row(Row::new().with_text("Normal row"))
        .with_row(Row::new().with_text("Taller row").with_height(30.0))
        .with_row(Row::new().with_text("Hidden row").with_hidden(true))
        .with_row(
            Row::new()
                .with_text("Grouped detail row")
                .with_outline_level(1),
        );

    let frozen_panes_sheet = Sheet::new("Frozen panes")
        .with_row(
            Row::new()
                .with_cell(Cell::text("Frozen header"))
                .with_cell(Cell::text("Frozen header")),
        )
        .with_row(
            Row::new()
                .with_cell(Cell::text("Scrolling data"))
                .with_cell(Cell::number(1.0)),
        )
        .with_freeze_panes(FreezePane::new(1, 1));

    let page_breaks_sheet = Sheet::new("Page breaks")
        .with_row(Row::new().with_text("Above this row: page break"))
        .with_row(Row::new().with_text("Below the break"))
        .with_row_break(1)
        .with_column_break(0)
        .with_outline_summary_below(false)
        .with_outline_summary_right(false);

    let workbook = Workbook::new()
        .with_sheet(merged_sheet)
        .with_sheet(columns_sheet)
        .with_sheet(rows_sheet)
        .with_sheet(frozen_panes_sheet)
        .with_sheet(page_breaks_sheet);

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

pub fn with_column_break(self, column: u32) -> Sheet

Adds a manual page break after the given 1-based column number and returns the sheet for chaining.

Examples found in repository

examples/xlsx_structure_and_layout.rs (line 62)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_structure_and_layout.xlsx");

    let merged_sheet = Sheet::new("Merged cells")
        .with_row(Row::new().with_text("This title spans three columns"))
        .with_merged_range("A1:C1");

    let columns_sheet = Sheet::new("Columns")
        .with_row(
            Row::new()
                .with_cell(Cell::text("Wide"))
                .with_cell(Cell::text("Hidden"))
                .with_cell(Cell::text("Grouped")),
        )
        .with_column_setting(ColumnSetting::new(0).with_width(30.0))
        .with_column_setting(ColumnSetting::new(1).with_hidden(true))
        .with_column_setting(
            ColumnSetting::new(2)
                .with_outline_level(1)
                .with_collapsed(false),
        );

    let rows_sheet = Sheet::new("Rows")
        .with_row(Row::new().with_text("Normal row"))
        .with_row(Row::new().with_text("Taller row").with_height(30.0))
        .with_row(Row::new().with_text("Hidden row").with_hidden(true))
        .with_row(
            Row::new()
                .with_text("Grouped detail row")
                .with_outline_level(1),
        );

    let frozen_panes_sheet = Sheet::new("Frozen panes")
        .with_row(
            Row::new()
                .with_cell(Cell::text("Frozen header"))
                .with_cell(Cell::text("Frozen header")),
        )
        .with_row(
            Row::new()
                .with_cell(Cell::text("Scrolling data"))
                .with_cell(Cell::number(1.0)),
        )
        .with_freeze_panes(FreezePane::new(1, 1));

    let page_breaks_sheet = Sheet::new("Page breaks")
        .with_row(Row::new().with_text("Above this row: page break"))
        .with_row(Row::new().with_text("Below the break"))
        .with_row_break(1)
        .with_column_break(0)
        .with_outline_summary_below(false)
        .with_outline_summary_right(false);

    let workbook = Workbook::new()
        .with_sheet(merged_sheet)
        .with_sheet(columns_sheet)
        .with_sheet(rows_sheet)
        .with_sheet(frozen_panes_sheet)
        .with_sheet(page_breaks_sheet);

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

pub fn with_scenario(self, scenario: Scenario) -> Sheet

Appends a “what-if” scenario and returns the sheet for chaining.

Examples found in repository

examples/xlsx_workbook_metadata.rs (lines 30-35)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_workbook_metadata.xlsx");

    let named_ranges_sheet = Sheet::new("Named ranges")
        .with_row(Row::new().with_text("Tax rate").with_number(0.0825))
        .with_row(Row::new().with_cell(Cell::formula("TaxRate*100").with_cached_value(8.25)));

    let calculation_sheet = Sheet::new("Calculation").with_row(
        Row::new().with_text("Set to manual recalculation with iterative calculation enabled."),
    );

    let scenarios_sheet = Sheet::new("Scenarios")
        .with_row(Row::new().with_text("Revenue").with_number(100_000.0))
        .with_row(Row::new().with_text("Cost").with_number(60_000.0))
        .with_scenario(
            Scenario::new("Best case")
                .with_input("B1", "150000")
                .with_input("B2", "55000")
                .with_comment("Optimistic projection"),
        )
        .with_scenario(
            Scenario::new("Worst case")
                .with_input("B1", "70000")
                .with_input("B2", "65000"),
        );

    let auto_filter_sheet = Sheet::new("Autofilter criteria")
        .with_row(Row::new().with_text("Region"))
        .with_row(Row::new().with_text("North"))
        .with_row(Row::new().with_text("South"))
        .with_auto_filter_range("A1:A3")
        .with_auto_filter_column(AutoFilterColumn::new(0, vec!["North".to_string()]));

    let ignored_errors_sheet = Sheet::new("Ignored errors")
        .with_row(Row::new().with_text("123")) // a number stored as text — normally flagged by Excel
        .with_ignored_error(IgnoredError::new("A1:A1").with_number_stored_as_text(true));

    let workbook = Workbook::new()
        .with_defined_name(DefinedName::new("TaxRate", "'Named ranges'!$B$1"))
        .with_calculation(
            CalculationProperties::new()
                .with_mode(CalculationMode::Manual)
                .with_iterate(true),
        )
        .with_sheet(named_ranges_sheet)
        .with_sheet(calculation_sheet)
        .with_sheet(scenarios_sheet)
        .with_sheet(auto_filter_sheet)
        .with_sheet(ignored_errors_sheet);

    // `Workbook.properties` has no `with_*` builder — it's set directly,
    // like any other public field.
    let properties = DocumentProperties::new()
        .with_title("Metadata example")
        .with_author("Example Author")
        .with_subject("Workbook-level features")
        .with_custom_property(
            "ProjectCode",
            CustomPropertyValue::Text("XLSX-META".to_string()),
        );
    let workbook = Workbook {
        properties,
        ..workbook
    };

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

pub fn with_auto_filter_column(self, column: AutoFilterColumn) -> Sheet

Appends an autofilter column’s criteria and returns the sheet for chaining.

Examples found in repository

examples/xlsx_workbook_metadata.rs (line 47)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_workbook_metadata.xlsx");

    let named_ranges_sheet = Sheet::new("Named ranges")
        .with_row(Row::new().with_text("Tax rate").with_number(0.0825))
        .with_row(Row::new().with_cell(Cell::formula("TaxRate*100").with_cached_value(8.25)));

    let calculation_sheet = Sheet::new("Calculation").with_row(
        Row::new().with_text("Set to manual recalculation with iterative calculation enabled."),
    );

    let scenarios_sheet = Sheet::new("Scenarios")
        .with_row(Row::new().with_text("Revenue").with_number(100_000.0))
        .with_row(Row::new().with_text("Cost").with_number(60_000.0))
        .with_scenario(
            Scenario::new("Best case")
                .with_input("B1", "150000")
                .with_input("B2", "55000")
                .with_comment("Optimistic projection"),
        )
        .with_scenario(
            Scenario::new("Worst case")
                .with_input("B1", "70000")
                .with_input("B2", "65000"),
        );

    let auto_filter_sheet = Sheet::new("Autofilter criteria")
        .with_row(Row::new().with_text("Region"))
        .with_row(Row::new().with_text("North"))
        .with_row(Row::new().with_text("South"))
        .with_auto_filter_range("A1:A3")
        .with_auto_filter_column(AutoFilterColumn::new(0, vec!["North".to_string()]));

    let ignored_errors_sheet = Sheet::new("Ignored errors")
        .with_row(Row::new().with_text("123")) // a number stored as text — normally flagged by Excel
        .with_ignored_error(IgnoredError::new("A1:A1").with_number_stored_as_text(true));

    let workbook = Workbook::new()
        .with_defined_name(DefinedName::new("TaxRate", "'Named ranges'!$B$1"))
        .with_calculation(
            CalculationProperties::new()
                .with_mode(CalculationMode::Manual)
                .with_iterate(true),
        )
        .with_sheet(named_ranges_sheet)
        .with_sheet(calculation_sheet)
        .with_sheet(scenarios_sheet)
        .with_sheet(auto_filter_sheet)
        .with_sheet(ignored_errors_sheet);

    // `Workbook.properties` has no `with_*` builder — it's set directly,
    // like any other public field.
    let properties = DocumentProperties::new()
        .with_title("Metadata example")
        .with_author("Example Author")
        .with_subject("Workbook-level features")
        .with_custom_property(
            "ProjectCode",
            CustomPropertyValue::Text("XLSX-META".to_string()),
        );
    let workbook = Workbook {
        properties,
        ..workbook
    };

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

pub fn with_ignored_error(self, ignored_error: IgnoredError) -> Sheet

Appends a suppressed error-checking entry and returns the sheet for chaining.

Examples found in repository

examples/xlsx_workbook_metadata.rs (line 51)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_workbook_metadata.xlsx");

    let named_ranges_sheet = Sheet::new("Named ranges")
        .with_row(Row::new().with_text("Tax rate").with_number(0.0825))
        .with_row(Row::new().with_cell(Cell::formula("TaxRate*100").with_cached_value(8.25)));

    let calculation_sheet = Sheet::new("Calculation").with_row(
        Row::new().with_text("Set to manual recalculation with iterative calculation enabled."),
    );

    let scenarios_sheet = Sheet::new("Scenarios")
        .with_row(Row::new().with_text("Revenue").with_number(100_000.0))
        .with_row(Row::new().with_text("Cost").with_number(60_000.0))
        .with_scenario(
            Scenario::new("Best case")
                .with_input("B1", "150000")
                .with_input("B2", "55000")
                .with_comment("Optimistic projection"),
        )
        .with_scenario(
            Scenario::new("Worst case")
                .with_input("B1", "70000")
                .with_input("B2", "65000"),
        );

    let auto_filter_sheet = Sheet::new("Autofilter criteria")
        .with_row(Row::new().with_text("Region"))
        .with_row(Row::new().with_text("North"))
        .with_row(Row::new().with_text("South"))
        .with_auto_filter_range("A1:A3")
        .with_auto_filter_column(AutoFilterColumn::new(0, vec!["North".to_string()]));

    let ignored_errors_sheet = Sheet::new("Ignored errors")
        .with_row(Row::new().with_text("123")) // a number stored as text — normally flagged by Excel
        .with_ignored_error(IgnoredError::new("A1:A1").with_number_stored_as_text(true));

    let workbook = Workbook::new()
        .with_defined_name(DefinedName::new("TaxRate", "'Named ranges'!$B$1"))
        .with_calculation(
            CalculationProperties::new()
                .with_mode(CalculationMode::Manual)
                .with_iterate(true),
        )
        .with_sheet(named_ranges_sheet)
        .with_sheet(calculation_sheet)
        .with_sheet(scenarios_sheet)
        .with_sheet(auto_filter_sheet)
        .with_sheet(ignored_errors_sheet);

    // `Workbook.properties` has no `with_*` builder — it's set directly,
    // like any other public field.
    let properties = DocumentProperties::new()
        .with_title("Metadata example")
        .with_author("Example Author")
        .with_subject("Workbook-level features")
        .with_custom_property(
            "ProjectCode",
            CustomPropertyValue::Text("XLSX-META".to_string()),
        );
    let workbook = Workbook {
        properties,
        ..workbook
    };

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

pub fn with_protected_range(self, protected_range: ProtectedRange) -> Sheet

Appends a named protected range and returns the sheet for chaining.

Examples found in repository

examples/xlsx_protection.rs (line 29)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_protection.xlsx");

    let sheet_protection_sheet = Sheet::new("Sheet protection")
        .with_row(Row::new().with_text("Locked: this sheet is protected with a password."))
        .with_protection(SheetProtection::with_password("secret"));

    let protected_range_sheet = Sheet::new("Protected range")
        .with_row(
            Row::new()
                .with_text("A1 is protected; B1 stays editable via a named unprotected range."),
        )
        .with_protection(SheetProtection::locked())
        .with_protected_range(ProtectedRange::new("EditableArea", "B1:B1").with_password("secret"));

    let workbook = Workbook::new()
        .with_write_protection(
            WriteProtection::recommended()
                .with_user_name("Author")
                .with_password("secret"),
        )
        .with_sheet(sheet_protection_sheet)
        .with_sheet(protected_range_sheet);

    // `Workbook.protection` (structure protection: locking sheet
    // add/rename/hide/reorder/delete) has no `with_*` builder — it's set
    // directly, like any other public field.
    let workbook = Workbook {
        protection: Some(WorkbookProtection::locked().with_lock_windows(true)),
        ..workbook
    };

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

pub fn with_sort_state(self, sort_state: SortState) -> Sheet

Sets this sheet’s (worksheet-level <autoFilter>) remembered sort order and returns the sheet for chaining. See Sheet::sort_state’s doc comment: a no-op unless with_auto_filter_range is also used.

pub fn with_outline_summary_below(self, summary_below: bool) -> Sheet

Sets whether outline/grouping summary rows sit below (true) or above (false) their detail rows, and returns the sheet for chaining.

Examples found in repository

examples/xlsx_structure_and_layout.rs (line 63)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_structure_and_layout.xlsx");

    let merged_sheet = Sheet::new("Merged cells")
        .with_row(Row::new().with_text("This title spans three columns"))
        .with_merged_range("A1:C1");

    let columns_sheet = Sheet::new("Columns")
        .with_row(
            Row::new()
                .with_cell(Cell::text("Wide"))
                .with_cell(Cell::text("Hidden"))
                .with_cell(Cell::text("Grouped")),
        )
        .with_column_setting(ColumnSetting::new(0).with_width(30.0))
        .with_column_setting(ColumnSetting::new(1).with_hidden(true))
        .with_column_setting(
            ColumnSetting::new(2)
                .with_outline_level(1)
                .with_collapsed(false),
        );

    let rows_sheet = Sheet::new("Rows")
        .with_row(Row::new().with_text("Normal row"))
        .with_row(Row::new().with_text("Taller row").with_height(30.0))
        .with_row(Row::new().with_text("Hidden row").with_hidden(true))
        .with_row(
            Row::new()
                .with_text("Grouped detail row")
                .with_outline_level(1),
        );

    let frozen_panes_sheet = Sheet::new("Frozen panes")
        .with_row(
            Row::new()
                .with_cell(Cell::text("Frozen header"))
                .with_cell(Cell::text("Frozen header")),
        )
        .with_row(
            Row::new()
                .with_cell(Cell::text("Scrolling data"))
                .with_cell(Cell::number(1.0)),
        )
        .with_freeze_panes(FreezePane::new(1, 1));

    let page_breaks_sheet = Sheet::new("Page breaks")
        .with_row(Row::new().with_text("Above this row: page break"))
        .with_row(Row::new().with_text("Below the break"))
        .with_row_break(1)
        .with_column_break(0)
        .with_outline_summary_below(false)
        .with_outline_summary_right(false);

    let workbook = Workbook::new()
        .with_sheet(merged_sheet)
        .with_sheet(columns_sheet)
        .with_sheet(rows_sheet)
        .with_sheet(frozen_panes_sheet)
        .with_sheet(page_breaks_sheet);

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

pub fn with_outline_summary_right(self, summary_right: bool) -> Sheet

Sets whether outline/grouping summary columns sit to the right (true) or left (false) of their detail columns, and returns the sheet for chaining — point 55, the column-axis counterpart of with_outline_summary_below.

Examples found in repository

examples/xlsx_structure_and_layout.rs (line 64)

fn main() -> office_toolkit::Result<()> {
    let path = output_path("xlsx_structure_and_layout.xlsx");

    let merged_sheet = Sheet::new("Merged cells")
        .with_row(Row::new().with_text("This title spans three columns"))
        .with_merged_range("A1:C1");

    let columns_sheet = Sheet::new("Columns")
        .with_row(
            Row::new()
                .with_cell(Cell::text("Wide"))
                .with_cell(Cell::text("Hidden"))
                .with_cell(Cell::text("Grouped")),
        )
        .with_column_setting(ColumnSetting::new(0).with_width(30.0))
        .with_column_setting(ColumnSetting::new(1).with_hidden(true))
        .with_column_setting(
            ColumnSetting::new(2)
                .with_outline_level(1)
                .with_collapsed(false),
        );

    let rows_sheet = Sheet::new("Rows")
        .with_row(Row::new().with_text("Normal row"))
        .with_row(Row::new().with_text("Taller row").with_height(30.0))
        .with_row(Row::new().with_text("Hidden row").with_hidden(true))
        .with_row(
            Row::new()
                .with_text("Grouped detail row")
                .with_outline_level(1),
        );

    let frozen_panes_sheet = Sheet::new("Frozen panes")
        .with_row(
            Row::new()
                .with_cell(Cell::text("Frozen header"))
                .with_cell(Cell::text("Frozen header")),
        )
        .with_row(
            Row::new()
                .with_cell(Cell::text("Scrolling data"))
                .with_cell(Cell::number(1.0)),
        )
        .with_freeze_panes(FreezePane::new(1, 1));

    let page_breaks_sheet = Sheet::new("Page breaks")
        .with_row(Row::new().with_text("Above this row: page break"))
        .with_row(Row::new().with_text("Below the break"))
        .with_row_break(1)
        .with_column_break(0)
        .with_outline_summary_below(false)
        .with_outline_summary_right(false);

    let workbook = Workbook::new()
        .with_sheet(merged_sheet)
        .with_sheet(columns_sheet)
        .with_sheet(rows_sheet)
        .with_sheet(frozen_panes_sheet)
        .with_sheet(page_breaks_sheet);

    workbook.save_to_file(&path)?;
    println!("Wrote {}", path.display());
    Ok(())
}

Trait Implementations

impl Clone for Sheet

fn clone(&self) -> Sheet

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Sheet

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for Sheet

fn default() -> Sheet

Returns the “default value” for a type.

impl PartialEq for Sheet

fn eq(&self, other: &Sheet) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Sheet