Struct Workbook

pub struct Workbook {
    pub sheets: Vec<WorkSheet>,
    /* private fields */
}

Fields

sheets: Vec<WorkSheet>

Implementations

impl Workbook

pub fn new() -> Workbook

Examples found in repository

examples/background.rs (line 5)

fn main() -> WorkbookResult<()> {
    // Create a new workbook
    let mut workbook = Workbook::new();
    // Use the default worksheet
    let worksheet = workbook.get_worksheet_mut(1)?;
    // Set the background image.
    // **NOTICE**: Only png format is acceptable in the background image
    worksheet.set_background("examples/pics/ferris.png")?;

    workbook.save_as("examples/background.xlsx")?;
    Ok(())
}

examples/image.rs (line 4)

fn main() -> WorkbookResult<()> {
    let mut workbook = Workbook::new();
    let worksheet = workbook.get_worksheet_mut(1)?;
    // 0.4.0+ Feature: Support for inserting images in the following formats:
    // jpg, png, gif, webp, tif
    worksheet.insert_image("A1:C7", &"./examples/pics/capybara.bmp")?;
    worksheet.insert_image("C7:E14", &"./examples/pics/rust.png")?;
    workbook.save_as("examples/image.xlsx")?;
    Ok(())
}

examples/tab_color.rs (line 5)

fn main() -> WorkbookResult<()> {
    // Create a new workbook
    let mut workbook = Workbook::new();
    // Set up some worksheets and set tab colors
    let worksheet1 = workbook.get_worksheet_mut(1)?;
    worksheet1.set_tab_color(&FormatColor::RGB(255, 0, 0)); // Red
    let worksheet2 = workbook.add_worksheet()?;
    worksheet2.set_tab_color(&FormatColor::Index(11)); // Green
    let worksheet3 = workbook.add_worksheet()?;
    worksheet3.set_tab_color(&FormatColor::Theme(5, 0.0)); // Orange
    let worksheet4 = workbook.add_worksheet()?;
    // worksheet4 will have the default color.
    workbook.save_as("examples/tab_color.xlsx")?;
    Ok(())
}

examples/hide_row_col.rs (line 5)

fn main() -> WorkbookResult<()> {
    // Create a new workbook
    let mut workbook = Workbook::new();

    let worksheet = workbook.get_worksheet_mut(1)?;

    // Write some data.
    worksheet.write("D1", "Some hidden columns.")?;
    worksheet.write("A8", "Some hidden rows.")?;

    // Hide all rows without data.
    worksheet.hide_unused_rows(true);

    // Set the height of empty rows that we do want to display even if it is
    // the default height.
    for row in 2..=7 {
        worksheet.set_row_height(row, 15.0)?;
    }

    // Columns can be hidden explicitly. This doesn't increase the file size..
    worksheet.hide_columns("G:XFD")?;

    workbook.save_as("examples/hide_row_col.xlsx")?;
    Ok(())
}

examples/text_indent.rs (line 5)

fn main() -> WorkbookResult<()> {
    // Create a new workbook
    let mut workbook = Workbook::new();
    let worksheet = workbook.get_worksheet_mut(1)?;

    let indent1 = Format::default().set_indent(1);
    let indent2 = Format::default().set_indent(2);

    worksheet.set_columns_width("A:A", 40.0)?;

    worksheet.write_with_format("A1", "This text is indented 1 level", &indent1)?;
    worksheet.write_with_format("A2", "This text is indented 2 levels", &indent2)?;

    // Note: Alignment is not applied correctly when changing the reading order, this bug will be fixed in the future!
    // let indent = Format::default().set_reading_order(2).set_align(FormatAlignType::Right).set_indent(2);
    // worksheet.right_to_left();

    workbook.save_as("examples/text_indent.xlsx")?;
    Ok(())
}

examples/doc_properties.rs (line 5)

fn main() -> WorkbookResult<()> {
    // Create a new workbook
    let mut workbook = Workbook::new();
    let mut properties = Properties::default();
    properties.set_title("This is an example spreadsheet")
        .set_subject("With document properties")
        .set_author("pt")
        .set_manager("example manager")
        .set_company("example company")
        .set_category("Example spreadsheets")
        .set_keywords("Sample, Example, Properties")
        .set_comments("Created with Rust")
        .set_status("example status");
    workbook.set_properties(&properties)?;
    // Use the default worksheet
    let worksheet = workbook.get_worksheet_mut(1)?;
    worksheet.set_columns_width("A:A", 70.0)?;
    worksheet.write("A1", "Select 'Workbook Properties' to see properties.")?;
    workbook.save_as("examples/doc_properties.xlsx")?;
    Ok(())
}

Additional examples can be found in:

• examples/merge.rs
• examples/array_formula.rs
• examples/hide_sheet.rs
• examples/old_array_formula.rs
• examples/lambda.rs
• examples/ignore_errors.rs
• examples/right_to_left.rs
• examples/defined_name.rs
• examples/read_and_copy.rs
• examples/hello_world.rs
• examples/panes.rs
• examples/outline_collapsed.rs
• examples/outline.rs
• examples/dynamic_arrays.rs
• examples/autofilter.rs

pub fn get_worksheet_mut(&mut self, id: u32) -> WorkbookResult<&mut WorkSheet>

Examples found in repository

examples/background.rs (line 7)

fn main() -> WorkbookResult<()> {
    // Create a new workbook
    let mut workbook = Workbook::new();
    // Use the default worksheet
    let worksheet = workbook.get_worksheet_mut(1)?;
    // Set the background image.
    // **NOTICE**: Only png format is acceptable in the background image
    worksheet.set_background("examples/pics/ferris.png")?;

    workbook.save_as("examples/background.xlsx")?;
    Ok(())
}

examples/image.rs (line 5)

fn main() -> WorkbookResult<()> {
    let mut workbook = Workbook::new();
    let worksheet = workbook.get_worksheet_mut(1)?;
    // 0.4.0+ Feature: Support for inserting images in the following formats:
    // jpg, png, gif, webp, tif
    worksheet.insert_image("A1:C7", &"./examples/pics/capybara.bmp")?;
    worksheet.insert_image("C7:E14", &"./examples/pics/rust.png")?;
    workbook.save_as("examples/image.xlsx")?;
    Ok(())
}

examples/tab_color.rs (line 7)

fn main() -> WorkbookResult<()> {
    // Create a new workbook
    let mut workbook = Workbook::new();
    // Set up some worksheets and set tab colors
    let worksheet1 = workbook.get_worksheet_mut(1)?;
    worksheet1.set_tab_color(&FormatColor::RGB(255, 0, 0)); // Red
    let worksheet2 = workbook.add_worksheet()?;
    worksheet2.set_tab_color(&FormatColor::Index(11)); // Green
    let worksheet3 = workbook.add_worksheet()?;
    worksheet3.set_tab_color(&FormatColor::Theme(5, 0.0)); // Orange
    let worksheet4 = workbook.add_worksheet()?;
    // worksheet4 will have the default color.
    workbook.save_as("examples/tab_color.xlsx")?;
    Ok(())
}

examples/hide_row_col.rs (line 7)

fn main() -> WorkbookResult<()> {
    // Create a new workbook
    let mut workbook = Workbook::new();

    let worksheet = workbook.get_worksheet_mut(1)?;

    // Write some data.
    worksheet.write("D1", "Some hidden columns.")?;
    worksheet.write("A8", "Some hidden rows.")?;

    // Hide all rows without data.
    worksheet.hide_unused_rows(true);

    // Set the height of empty rows that we do want to display even if it is
    // the default height.
    for row in 2..=7 {
        worksheet.set_row_height(row, 15.0)?;
    }

    // Columns can be hidden explicitly. This doesn't increase the file size..
    worksheet.hide_columns("G:XFD")?;

    workbook.save_as("examples/hide_row_col.xlsx")?;
    Ok(())
}

examples/text_indent.rs (line 6)

fn main() -> WorkbookResult<()> {
    // Create a new workbook
    let mut workbook = Workbook::new();
    let worksheet = workbook.get_worksheet_mut(1)?;

    let indent1 = Format::default().set_indent(1);
    let indent2 = Format::default().set_indent(2);

    worksheet.set_columns_width("A:A", 40.0)?;

    worksheet.write_with_format("A1", "This text is indented 1 level", &indent1)?;
    worksheet.write_with_format("A2", "This text is indented 2 levels", &indent2)?;

    // Note: Alignment is not applied correctly when changing the reading order, this bug will be fixed in the future!
    // let indent = Format::default().set_reading_order(2).set_align(FormatAlignType::Right).set_indent(2);
    // worksheet.right_to_left();

    workbook.save_as("examples/text_indent.xlsx")?;
    Ok(())
}

examples/doc_properties.rs (line 18)

fn main() -> WorkbookResult<()> {
    // Create a new workbook
    let mut workbook = Workbook::new();
    let mut properties = Properties::default();
    properties.set_title("This is an example spreadsheet")
        .set_subject("With document properties")
        .set_author("pt")
        .set_manager("example manager")
        .set_company("example company")
        .set_category("Example spreadsheets")
        .set_keywords("Sample, Example, Properties")
        .set_comments("Created with Rust")
        .set_status("example status");
    workbook.set_properties(&properties)?;
    // Use the default worksheet
    let worksheet = workbook.get_worksheet_mut(1)?;
    worksheet.set_columns_width("A:A", 70.0)?;
    worksheet.write("A1", "Select 'Workbook Properties' to see properties.")?;
    workbook.save_as("examples/doc_properties.xlsx")?;
    Ok(())
}

Additional examples can be found in:

• examples/merge.rs
• examples/array_formula.rs
• examples/hide_sheet.rs
• examples/old_array_formula.rs
• examples/lambda.rs
• examples/ignore_errors.rs
• examples/right_to_left.rs
• examples/duplicate_sheet.rs
• examples/read_and_copy.rs
• examples/hello_world.rs
• examples/autofilter.rs

pub fn get_worksheet(&self, id: u32) -> WorkbookResult<&WorkSheet>

Examples found in repository

examples/xlsx2adoc.rs (line 107)

pub fn xlsx_convert(
    in_file_name: &Path,
    out_file_name: &Path,
) -> Result<Xlsx2AdocTestResults, Error> {
    let workbook = Workbook::from_path(in_file_name);
    let mut workbook = workbook.unwrap();
    workbook.finish();

    let reading_sheet = workbook.get_worksheet(1);
    let sheet = reading_sheet.unwrap();
    let default_row_hight = sheet.get_default_row();

    println!(
        "Rows {} -> ? ( {} )",
        sheet.max_row(),
        //        formatted_row.len(),
        default_row_hight
    );

    let mut hights = Vec::<f64>::new();
    for _ in 0..sheet.max_row() {
        hights.push(default_row_hight);
    }

    let widths = find_col_width(sheet)?;
    let bounds = "|===\r";
    let line = tab_header(&widths);

    let mut output_file = File::create(out_file_name)?; // overwrites existing file
    let mut writer = BufWriter::new(&mut output_file);

    writer.write(line.as_bytes())?;
    writer.write(bounds.as_bytes())?;

    /*     // todo test
       writer.write("|1|2|3\r".as_bytes())?;
       writer.write("|4|5|6\r".as_bytes())?;

       writer.write(bounds.as_bytes())?;
    */
    for row in 0..sheet.max_row() {
        println!("Row {} ({})", row, hights[row as usize]);
        for col in 0..sheet.max_column() {
            if col < sheet.max_column() {
                writer.write("|".as_bytes())?;
            }

            let cell_content = sheet.read_cell((row + 1, col + 1)).unwrap_or_default();
            let format = cell_content.format;
            let mut text_color = FormatColor::Default;
            let mut bg_color = FormatColor::Default;
            let mut bg_bg_color = FormatColor::Default;
            if format.is_some() {
                let format = format.unwrap();
                text_color = format.get_color().clone();
                let ff = format.get_background().clone();
                bg_color = ff.fg_color.clone();
                bg_bg_color = ff.bg_color.clone();
            }

            let cell_format_string = format!(
                "Text-Color = {:?}        bg = {:?}        bg_bg = {:?}",
                text_color, bg_color, bg_bg_color
            );
            let cell_text = cell_content.text;
            let text = match cell_text {
                Some(t) => t,
                None => "-".to_owned(),
            };

            println!(
                "{} ({}) -> {}     Format: {}",
                col,
                widths[(col) as usize],
                text,
                cell_format_string
            );
            writer.write(text.as_bytes())?;
        }

        writer.write("\r".as_bytes())?;
    }
    writer.write(bounds.as_bytes())?;

    let xlsx_2_adoc_test_results = Xlsx2AdocTestResults { v1: 0, v2: 0 };
    Ok(xlsx_2_adoc_test_results)
}

pub fn get_worksheet_by_name(&self, name: &str) -> WorkbookResult<&WorkSheet>

Examples found in repository

examples/read_and_copy.rs (line 10)

fn main() -> WorkbookResult<()> {
    // Read an existed workbook
    let reading_book = Workbook::from_path("./tests/xlsx/accounting.xlsx")?;
    let reading_sheet = reading_book.get_worksheet_by_name("worksheet")?;
    // Create a new workbook to write
    let mut writing_book = Workbook::new();
    let writing_sheet = writing_book.get_worksheet_mut(1)?;

    // Synchronous column width and format
    let columns_map = reading_sheet.get_columns_with_format("A:XFD")?;
    match reading_sheet.get_default_column() {
        None => writing_sheet.set_default_column_adaptive(),
        Some(width) => writing_sheet.set_default_column(width),
    }
    columns_map.iter().for_each(|(col_range, (column, format))| {
        if let Some(format) = format {
            // if col format exists, write it to writing_sheet
            writing_sheet.set_columns_with_format(col_range, column, format).unwrap()
        } else {
            writing_sheet.set_columns(col_range, column).unwrap()
        }
    });

    // Synchronous row height and format
    writing_sheet.set_default_row(reading_sheet.get_default_row());
    for row_number in 1..=reading_sheet.max_row() {
        let (row, format) = reading_sheet.get_row_with_format(row_number)?;
        if let Some(format) = format {
            // if col format exists, write it to writing_sheet
            writing_sheet.set_row_with_format(row_number, &row, &format)?;
        } else {
            writing_sheet.set_row(row_number, &row)?;
        }
    }

    // Read then write text and format
    for row in 1..=reading_sheet.max_row() {
        for col in 1..=reading_sheet.max_column() {
            if let Ok(cell) = reading_sheet.read_cell((row, col)) {
                writing_sheet.write_cell((row, col), &cell)?;
            }
        }
    }

    writing_book.save_as("./examples/read_and_copy.xlsx")?;
    Ok(())
}

pub fn get_worksheet_mut_by_name( &mut self, name: &str, ) -> WorkbookResult<&mut WorkSheet>

pub fn add_worksheet(&mut self) -> WorkbookResult<&mut WorkSheet>

Examples found in repository

examples/tab_color.rs (line 9)

fn main() -> WorkbookResult<()> {
    // Create a new workbook
    let mut workbook = Workbook::new();
    // Set up some worksheets and set tab colors
    let worksheet1 = workbook.get_worksheet_mut(1)?;
    worksheet1.set_tab_color(&FormatColor::RGB(255, 0, 0)); // Red
    let worksheet2 = workbook.add_worksheet()?;
    worksheet2.set_tab_color(&FormatColor::Index(11)); // Green
    let worksheet3 = workbook.add_worksheet()?;
    worksheet3.set_tab_color(&FormatColor::Theme(5, 0.0)); // Orange
    let worksheet4 = workbook.add_worksheet()?;
    // worksheet4 will have the default color.
    workbook.save_as("examples/tab_color.xlsx")?;
    Ok(())
}

examples/hide_sheet.rs (line 12)

fn main() -> WorkbookResult<()> {
    // Create a new workbook
    let mut workbook = Workbook::new();
    let worksheet1 = workbook.get_worksheet_mut(1)?;

    worksheet1.set_columns_width("A:A", 30.0)?;
    worksheet1.write("A1", "Sheet2 is hidden")?;

    // Hide Sheet2. It won't be visible until it is unhidden in Excel.
    let worksheet2 = workbook.add_worksheet()?;
    worksheet2.set_columns_width("A:A", 30.0)?;
    // worksheet2.activate();
    worksheet2.hide();
    worksheet2.write("A1", "Now it's my turn to find you!")?;
    // Note, you can't hide the "active" worksheet, which generally is the
    // first worksheet, since this would cause an Excel error. So, in order to hide
    // the first sheet you will need to activate another worksheet:
    //
    //    worksheet2.activate();
    //    worksheet1.hide();

    let worksheet3 = workbook.add_worksheet()?;
    worksheet3.set_columns_width("A:A", 30.0)?;
    worksheet3.write("A1", "Sheet2 is hidden")?;

    workbook.save_as("examples/hide_sheet.xlsx")?;
    Ok(())
}

examples/right_to_left.rs (line 23)

fn main() -> WorkbookResult<()> {
    // Add the cell formats.
    let format_left_to_right = Format::default()
        .set_reading_order(1);
    let format_right_to_left = Format::default()
        .set_reading_order(2);

    // Create a new workbook
    let mut workbook = Workbook::new();
    // Set up some worksheets and set tab colors
    let worksheet1 = workbook.get_worksheet_mut(1)?;

    // Make the columns wider for clarity.
    worksheet1.set_columns_width("A:A", 25.0)?;

    // Standard direction:         | A1 | B1 | C1 | ...
    worksheet1.write("A1", "نص عربي / English text")?;  // Default direction.
    worksheet1.write_with_format("A2", "نص عربي / English text", &format_left_to_right)?;
    worksheet1.write_with_format("A3", "نص عربي / English text", &format_right_to_left)?;

    let worksheet2 = workbook.add_worksheet()?;
    worksheet2.set_columns_width("A:A", 25.0)?;
    worksheet2.right_to_left();

    // Right to left direction:    ... | C1 | B1 | A1 |
    worksheet2.write("A1", "نص عربي / English text")?;  // Default direction.
    worksheet2.write_with_format("A2", "نص عربي / English text", &format_left_to_right)?;
    worksheet2.write_with_format("A3", "نص عربي / English text", &format_right_to_left)?;

    workbook.save_as("examples/right_to_left.xlsx")?;

    Ok(())
}

examples/defined_name.rs (line 6)

fn main() -> WorkbookResult<()> {
    // Create a new workbook
    let mut workbook = Workbook::new();
    workbook.add_worksheet()?;

    // Define some global/workbook names.
    workbook.define_name("Exchange_rate", "0.96")?;
    workbook.define_name("Sales", "Sheet1!$G$1:$H$10")?;
    // Define a local/worksheet name. Over-rides the "Sales" name above.
    workbook.define_local_name("Sales", "Sheet2!$G$1:$G$10", 2)?;

    // Write some text in the file and one of the defined names in a formula.
    let sales = ["Apple", "Grape", "Pear", "Banana", "Apple", "Grape", "Pear", "Banana", "Banana", "Pear"];
    let units = [10, 12, 32, 16, 13, 50, 25, 8, 33, 95];
    for worksheet in workbook.worksheets_mut() {
        worksheet.set_columns_width("A:B", 40.0)?;
        worksheet.set_columns_width("F:F", 40.0)?;
        worksheet.write("A1", "This worksheet contains some defined names.")?;
        worksheet.write("B1", "Show defined name Sales on the right->")?;
        worksheet.write_formula("C1", "=Sales")?;
        // In older versions of Excel, you could use the write_old_formula method:
        // worksheet.write_old_formula("C1", "=Sales")?;
        worksheet.write("A2", "See Formulas -> Name Manager above.")?;
        worksheet.write("A3", "Example formula in cell B3 ->")?;
        worksheet.write_formula("B3", "=Exchange_rate")?;
        // In older versions of Excel, you could use the write_old_formula method:
        // worksheet.write_old_formula("B3", "=Exchange_rate")?;
        worksheet.write("F1", "Fill in some arrays on the right->")?;
        worksheet.write_column("G1", &sales)?;
        worksheet.write_column("H1", &units)?;
    }

    workbook.save_as("examples/defined_name.xlsx")?;
    Ok(())
}

examples/autofilter.rs (line 15)

fn main() -> WorkbookResult<()> {
    // Prepare autofilter data
    let text = fs::read_to_string("examples/autofilter_data.txt").unwrap();
    let mut text = text.split("\n");
    let headers: Vec<&str> = text.next().unwrap().split_whitespace().collect();
    let mut data: Vec<Vec<&str>> = vec![];
    for text in text { data.push(text.split_whitespace().collect()) }

    // Create a new workbook
    let mut workbook = Workbook::new();
    // Add some worksheets
    workbook.add_worksheet()?;
    workbook.add_worksheet()?;
    workbook.add_worksheet()?;
    workbook.add_worksheet()?;
    workbook.add_worksheet()?;
    workbook.add_worksheet()?;

    // Set up several sheets with the same data.
    for worksheet in workbook.worksheets_mut() {
        // Make the columns wider.
        worksheet.set_columns_width("A:D", 12.0)?;
        // // Make the header row larger.
        worksheet.set_row_height_with_format(1, 20.0, &Format::default().set_bold())?;
        // Make the headers bold.
        worksheet.write_row("A1", &headers)?;
    }

    //
    // Example 1. Autofilter without conditions.
    //

    let worksheet1 = workbook.get_worksheet_mut(1)?;
    // Set the autofilter.
    worksheet1.autofilter("A1:D51");
    let mut row = 2;
    for row_data in &data {
        let mut col = 1;
        for data in row_data {
            if let Ok(num) = data.parse::<i32>() {
                worksheet1.write((row, col), num)?;
            } else {
                worksheet1.write((row, col), *data)?;
            }
            col += 1;
        }
        // Move on to the next worksheet row.
        row += 1;
    }


    //
    // Example 2. Autofilter with a filter condition in the first column.
    //
    let worksheet2 = workbook.get_worksheet_mut(2)?;
    // Set the autofilter.
    worksheet2.autofilter("A1:D51");
    // Add filter criteria.
    let mut filters = Filters::new();
    filters.and(Filter::eq("East"));
    worksheet2.filter_column("A", &filters);
    // Hide the rows that don't match the filter criteria.
    let mut row = 2;
    for row_data in &data {
        let mut col = 1;
        let data = row_data.get(0);
        // Check for rows that match the filter.
        if data != Some(&"East") {
            // We need to hide rows that don't match the filter.
            worksheet2.hide_row(row)?;
        }
        for data in row_data {
            if let Ok(num) = data.parse::<i32>() {
                worksheet2.write((row, col), num)?;
            } else {
                worksheet2.write((row, col), *data)?;
            }
            col += 1;
        }
        // Move on to the next worksheet row.
        row += 1;
    }

    //
    // Example 3. Autofilter with a filter condition in the first column.
    //
    let worksheet3 = workbook.get_worksheet_mut(3)?;
    // Set the autofilter.
    worksheet3.autofilter("A1:D51");
    // Add filter criteria.
    let mut filters = Filters::new();
    filters.and(Filter::eq("East")).or(Filter::eq("South"));
    worksheet3.filter_column("A", &filters);
    // Hide the rows that don't match the filter criteria.
    let mut row = 2;
    for row_data in &data {
        let mut col = 1;
        let data = row_data.get(0);
        // Check for rows that match the filter.
        if data != Some(&"East") && data != Some(&"South") {
            // We need to hide rows that don't match the filter.
            worksheet3.hide_row(row)?;
        }
        for data in row_data {
            if let Ok(num) = data.parse::<i32>() {
                worksheet3.write((row, col), num)?;
            } else {
                worksheet3.write((row, col), *data)?;
            }
            col += 1;
        }
        // Move on to the next worksheet row.
        row += 1;
    }


    //
    // Example 4. Autofilter with filter conditions in two columns.
    //
    let worksheet4 = workbook.get_worksheet_mut(4)?;
    // Set the autofilter.
    worksheet4.autofilter("A1:D51");
    // Add filter criteria.
    let mut filters_a = Filters::new();
    filters_a.and(Filter::eq("East"));
    worksheet4.filter_column("A", &filters_a);
    let mut filters_c = Filters::new();
    filters_c.and(Filter::gt("3000")).and(Filter::lt("8000"));
    worksheet4.filter_column("C", &filters_c);
    // Hide the rows that don't match the filter criteria.
    let mut row = 2;
    for row_data in &data {
        let mut col = 1;
        let data = row_data.get(0);
        // Check for rows that match the filter.
        if data != Some(&"East") {
            // We need to hide rows that don't match the filter.
            worksheet4.hide_row(row)?;
        }
        for data in row_data {
            if let Ok(num) = data.parse::<i32>() {
                if num <= 3000 || num >= 8000 {
                    worksheet4.hide_row(row)?;
                }
                worksheet4.write((row, col), num)?;
            } else {
                worksheet4.write((row, col), *data)?;
            }
            col += 1;
        }
        // Move on to the next worksheet row.
        row += 1;
    }


    //
    // Example 5. Autofilter with a filter list condition in one of the columns.
    //
    let worksheet5 = workbook.get_worksheet_mut(5)?;
    // Set the autofilter.
    worksheet5.autofilter("A1:D51");
    // Add filter criteria.
    let filters_list = Filters::eq(vec!["East", "North", "South"]);
    worksheet5.filter_column("A", &filters_list);
    // Hide the rows that don't match the filter criteria.
    let mut row = 2;
    for row_data in &data {
        let mut col = 1;
        let data = row_data.get(0);
        // Check for rows that match the filter.
        if data != Some(&"East") && data != Some(&"North") && data != Some(&"South") {
            // We need to hide rows that don't match the filter.
            worksheet5.hide_row(row)?;
        }
        for data in row_data {
            if let Ok(num) = data.parse::<i32>() {
                worksheet5.write((row, col), num)?;
            } else {
                worksheet5.write((row, col), *data)?;
            }
            col += 1;
        }
        // Move on to the next worksheet row.
        row += 1;
    }

    //
    // Example 6. Autofilter with filter for blanks.
    //
    let worksheet6 = workbook.get_worksheet_mut(6)?;
    // Set the autofilter.
    worksheet6.autofilter("A1:D51");
    // Add filter criteria.
    let filters = Filters::blank();
    worksheet6.filter_column("A", &filters);
    // Hide the rows that don't match the filter criteria.
    let mut row = 2;
    // Simulate a blank cell in the data.
    data[5][0] = "";

    for row_data in &data {
        let mut col = 1;
        let data = row_data.get(0);
        // Check for rows that match the filter.
        if data != Some(&"") {
            // We need to hide rows that don't match the filter.
            worksheet6.hide_row(row)?;
        }
        for data in row_data {
            if let Ok(num) = data.parse::<i32>() {
                worksheet6.write((row, col), num)?;
            } else {
                worksheet6.write((row, col), *data)?;
            }
            col += 1;
        }
        // Move on to the next worksheet row.
        row += 1;
    }

    //
    // Example 7. Autofilter with filter for non-blanks.
    //
    let worksheet7 = workbook.get_worksheet_mut(7)?;
    // Set the autofilter.
    worksheet7.autofilter("A1:D51");
    // Add filter criteria.
    let filters = Filters::not_blank();
    worksheet7.filter_column("A", &filters);
    // Hide the rows that don't match the filter criteria.
    let mut row = 2;
    // Simulate a blank cell in the data.

    for row_data in &data {
        let mut col = 1;
        let data = row_data.get(0);
        // Check for rows that match the filter.
        if data == Some(&"") {
            // We need to hide rows that don't match the filter.
            worksheet7.hide_row(row)?;
        }
        for data in row_data {
            if let Ok(num) = data.parse::<i32>() {
                worksheet7.write((row, col), num)?;
            } else {
                worksheet7.write((row, col), *data)?;
            }
            col += 1;
        }
        // Move on to the next worksheet row.
        row += 1;
    }


    workbook.save_as("examples/autofilter.xlsx")?;

    Ok(())
}

pub fn add_worksheet_by_name( &mut self, name: &str, ) -> WorkbookResult<&mut WorkSheet>

Examples found in repository

examples/hello_world.rs (line 35)

fn main() -> WorkbookResult<()> {
    // Create a new workbook
    let mut workbook = Workbook::new();
    let worksheet = workbook.get_worksheet_mut(1)?;
    // write some text
    WorkSheet::write(worksheet, "A1", "Hello")?;
    worksheet.write("B1", "World")?;
    worksheet.write("C1", "Rust")?;
    // Adjust font size
    let big = Format::default().set_size(32);
    worksheet.write_with_format("B1", "big text", &big)?;
    // Change font color
    let red = Format::default().set_color(FormatColor::RGB(255, 119, 119));
    worksheet.write_with_format("C1", "red text", &red)?;
    // Change the font style
    let bold = red.set_bold();
    worksheet.write_with_format("D1", "red bold text", &bold)?;
    // Change font
    let font = Format::default().set_font("华文行楷");
    worksheet.write_with_format("E1", "你好", &font)?;
    // adjust the text align
    let left_top = Format::default().set_align(FormatAlignType::Left).set_align(FormatAlignType::Top);
    worksheet.write_with_format("A2", "left top", &left_top)?;
    // add borders
    let thin_border = Format::default().set_border(FormatBorderType::Thin);
    worksheet.write_with_format("B2", "bordered text", &thin_border)?;
    // add background
    let red_background = Format::default().set_background_color(FormatColor::RGB(255, 119, 119));
    worksheet.write_with_format("C2", "red", &red_background)?;
    // add a number
    worksheet.write("D2", std::f64::consts::PI)?;
    // add a new worksheet and set a tab color
    let worksheet = workbook.add_worksheet_by_name("Other examples")?;
    worksheet.set_tab_color(&FormatColor::RGB(255, 153, 0)); // Orange
    // Set a background.
    worksheet.set_background("examples/pics/ferris.png")?;
    // Create a format to use in the merged range.
    let merge_format = Format::default()
        .set_bold()
        .set_border(FormatBorderType::Double)
        .set_align(FormatAlignType::Center)
        .set_align(FormatAlignType::VerticalCenter)
        .set_background_color(FormatColor::RGB(255, 255, 0));
    // Merge cells.
    worksheet.merge_range_with_format("A1:C3", "Merged Range", &merge_format)?;
    // Add an image
    worksheet.insert_image("A4:C10", &"./examples/pics/rust.png")?;
    workbook.save_as("examples/hello_world.xlsx")?;
    Ok(())
}

examples/panes.rs (line 18)

fn main() -> WorkbookResult<()> {
    let header_format = Format::default()
        .set_bold()
        .set_align(FormatAlignType::Center)
        .set_align(FormatAlignType::VerticalCenter)
        .set_border(FormatBorderType::Medium)
        .set_background_color(FormatColor::RGB(126, 75, 12));
    let center_format = Format::default().set_align(FormatAlignType::Center);

    // Create a new workbook
    let mut workbook = Workbook::new();

    //
    // Example 1. Freeze pane on the top row.
    //
    let worksheet1 = workbook.add_worksheet_by_name("Panes 1")?;
    worksheet1.freeze_panes("A2")?;
    // Other sheet formatting.
    worksheet1.set_columns_width("A:I", 16.0)?;
    worksheet1.set_row_height(0, 20.0)?;
    worksheet1.set_selection("C3:C3")?;

    // Some text to demonstrate scrolling.
    for col in 1..=9 {
        worksheet1.write_with_format((1, col), "Scroll down", &header_format)?;
    }

    for row in 2..100 {
        for col in 1..=9 {
            worksheet1.write_with_format((row, col), row, &center_format)?;
        }
    }

    //
    // Example 2. Freeze pane on the left column.
    //
    let worksheet2 = workbook.add_worksheet_by_name("Panes 2")?;
    worksheet2.freeze_panes("B1")?;

    // Other sheet formatting.
    worksheet2.set_columns_width("A:A", 16.0)?;
    worksheet2.set_selection("C3:C3")?;

    // Some text to demonstrate scrolling.
    for row in 1..=50 {
        worksheet2.write_with_format((row, 1), "Scroll right", &header_format)?;
        for col in 2..=26 {
            worksheet2.write_with_format((row, col), col, &center_format)?;
        }
    }

    //
    // Example 3. Freeze pane on the top row and left column.
    //
    let worksheet3 = workbook.add_worksheet_by_name("Panes 3")?;
    worksheet3.freeze_panes((2, 2))?;

    // Other sheet formatting.
    worksheet3.set_columns_width("A:Z", 16.0)?;
    worksheet3.set_row_height(1, 20.0)?;
    worksheet3.set_selection("C3:C3")?;
    worksheet3.write_with_format((1, 1), "", &header_format)?;

    // Some text to demonstrate scrolling.
    for col in 2..=26 {
        worksheet3.write_with_format((1, col), "Scroll down", &header_format)?;
    }

    for row in 2..=50 {
        worksheet3.write_with_format((row, 1), "Scroll right", &header_format)?;
        for col in 2..=26 {
            worksheet3.write_with_format((row, col), col, &center_format)?;
        }
    }

    //
    // Example 4. Split pane on the top row and left column.
    //
    // The divisions must be specified in terms of row and column dimensions.
    //
    let worksheet4 = workbook.add_worksheet_by_name("Panes 4")?;
    // Set the default row height is 17 and set the column width is 13
    worksheet4.set_columns_width("A:Z", 13.0)?;
    worksheet4.set_default_row(17.0);
    worksheet4.split_panes(2.0 * 13.0, 2.0 * 17.0)?;
    worksheet4.set_selection("C3:C3")?;

    // Some text to demonstrate scrolling.
    for col in 1..=26 {
        worksheet4.write_with_format((1, col), "Scroll", &center_format)?;
    }
    for row in 1..=50 {
        worksheet4.write_with_format((row, 1), "Scroll", &center_format)?;
        for col in 1..=26 {
            worksheet4.write_with_format((row, col), col, &center_format)?;
        }
    }

    workbook.save_as("examples/panes.xlsx")?;
    Ok(())
}

examples/outline_collapsed.rs (line 14)

fn main() -> WorkbookResult<()> {
    // Create a new workbook
    let mut workbook = Workbook::new();
    // Add a general format
    let bold = Format::default().set_bold();

    //
    // Example 1: A worksheet with outlined rows. It also includes SUBTOTAL()
    // functions so that it looks like the type of automatic outlines that are
    // generated when you use the Excel Data->SubTotals menu item.
    //
    let worksheet1 = workbook.add_worksheet_by_name("Outlined Rows")?;
    worksheet1.set_row_level(2, 2)?;
    worksheet1.set_row_level(3, 2)?;
    worksheet1.set_row_level(4, 2)?;
    worksheet1.set_row_level(5, 2)?;
    worksheet1.set_row_level(6, 1)?;
    worksheet1.set_row_level(7, 2)?;
    worksheet1.set_row_level(8, 2)?;
    worksheet1.set_row_level(9, 2)?;
    worksheet1.set_row_level(10, 2)?;
    worksheet1.set_row_level(11, 1)?;
    create_sub_totals(worksheet1)?;

    //
    // Example 2: Create a worksheet with collapsed outlined rows.
    // This is the same as the example 1  except that the all rows are collapsed.
    // Note: We need to indicate the rows that contains the collapsed symbol '+'
    // with the optional parameter, 'collapsed'.
    //
    let worksheet2 = workbook.add_worksheet_by_name("Collapsed Rows 1")?;
    worksheet2.set_row_level(2, 2)?;
    worksheet2.hide_row(2)?;
    worksheet2.set_row_level(3, 2)?;
    worksheet2.hide_row(3)?;
    worksheet2.set_row_level(4, 2)?;
    worksheet2.hide_row(4)?;
    worksheet2.set_row_level(5, 2)?;
    worksheet2.hide_row(5)?;
    worksheet2.set_row_level(6, 1)?;
    worksheet2.hide_row(6)?;
    worksheet2.set_row_level(7, 2)?;
    worksheet2.hide_row(7)?;
    worksheet2.set_row_level(8, 2)?;
    worksheet2.hide_row(8)?;
    worksheet2.set_row_level(9, 2)?;
    worksheet2.hide_row(9)?;
    worksheet2.set_row_level(10, 2)?;
    worksheet2.hide_row(10)?;
    worksheet2.set_row_level(11, 1)?;
    worksheet2.hide_row(11)?;

    worksheet2.collapse_row(12)?;

    // Write the sub-total data that is common to the row examples.
    create_sub_totals(worksheet2)?;


    //
    // Example 3: Create a worksheet with collapsed outlined rows.
    // Same as the example 1  except that the two sub-totals are collapsed.
    //
    let worksheet3 = workbook.add_worksheet_by_name("Collapsed Rows 2")?;
    worksheet3.set_row_level(2, 2)?;
    worksheet3.hide_row(2)?;
    worksheet3.set_row_level(3, 2)?;
    worksheet3.hide_row(3)?;
    worksheet3.set_row_level(4, 2)?;
    worksheet3.hide_row(4)?;
    worksheet3.set_row_level(5, 2)?;
    worksheet3.hide_row(5)?;
    worksheet3.set_row_level(6, 1)?;
    worksheet3.collapse_row(6)?;
    worksheet3.set_row_level(7, 2)?;
    worksheet3.hide_row(7)?;
    worksheet3.set_row_level(8, 2)?;
    worksheet3.hide_row(8)?;
    worksheet3.set_row_level(9, 2)?;
    worksheet3.hide_row(9)?;
    worksheet3.set_row_level(10, 2)?;
    worksheet3.hide_row(10)?;
    worksheet3.set_row_level(11, 1)?;
    worksheet3.collapse_row(11)?;
    // Write the sub-total data that is common to the row examples.
    create_sub_totals(worksheet3)?;


    //
    // Example 4: Create a worksheet with outlined rows.
    // Same as the example 1  except that the two sub-totals are collapsed.
    //
    let worksheet4 = workbook.add_worksheet_by_name("Collapsed Rows 3")?;
    worksheet4.set_row_level(2, 2)?;
    worksheet4.hide_row(2)?;
    worksheet4.set_row_level(3, 2)?;
    worksheet4.hide_row(3)?;
    worksheet4.set_row_level(4, 2)?;
    worksheet4.hide_row(4)?;
    worksheet4.set_row_level(5, 2)?;
    worksheet4.hide_row(5)?;
    worksheet4.set_row_level(6, 1)?;
    worksheet4.hide_row(6)?;
    worksheet4.collapse_row(6)?;
    worksheet4.set_row_level(7, 2)?;
    worksheet4.hide_row(7)?;
    worksheet4.set_row_level(8, 2)?;
    worksheet4.hide_row(8)?;
    worksheet4.set_row_level(9, 2)?;
    worksheet4.hide_row(9)?;
    worksheet4.set_row_level(10, 2)?;
    worksheet4.hide_row(10)?;
    worksheet4.set_row_level(11, 1)?;
    worksheet4.hide_row(11)?;
    worksheet4.collapse_row(11)?;
    worksheet4.collapse_row(12)?;
    // Write the sub-total data that is common to the row examples.
    create_sub_totals(worksheet4)?;



    //
    // Example 5: Create a worksheet with outlined columns.
    //
    let worksheet5 = workbook.add_worksheet_by_name("Outline Columns")?;
    worksheet5.set_row_height_with_format(1, 15.0, &bold)?;
    worksheet5.write_row("A1", &["Month", "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Total"])?;
    worksheet5.set_columns_width_with_format("A:A", 10.0, &bold)?;
    worksheet5.set_columns_width("B:G", 5.0)?;
    worksheet5.set_columns_level("B:G", 1)?;
    worksheet5.set_columns_width("H:H", 10.0)?;
    worksheet5.write_column("A2", &["North", "South", "East", "East"])?;
    worksheet5.write_row("B2", &[50, 20, 15, 25, 65, 80])?;
    worksheet5.write_row("B3", &[10, 20, 30, 50, 50, 50])?;
    worksheet5.write_row("B4", &[45, 75, 50, 15, 75, 100])?;
    worksheet5.write_row("B5", &[15, 15, 55, 35, 20, 50])?;
    worksheet5.write_formula("H2", "=SUM(B2:G2)")?;
    worksheet5.write_formula("H3", "=SUM(B3:G3)")?;
    worksheet5.write_formula("H4", "=SUM(B4:G4)")?;
    worksheet5.write_formula("H5", "=SUM(B5:G5)")?;
    worksheet5.write_formula_with_format("H6", "=SUM(H2:H5)", &bold)?;



    //
    // Example 6: Create a worksheet with collapsed outlined columns.
    // This is the same as the previous example except with collapsed columns.
    //
    let worksheet6 = workbook.add_worksheet_by_name("Collapsed Columns")?;
    worksheet6.set_row_height_with_format(1, 15.0, &bold)?;
    worksheet6.write_row("A1", &["Month", "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Total"])?;
    worksheet6.set_columns_width_with_format("A:H", 10.0, &bold)?;
    worksheet6.set_columns_level("B:G", 1)?;
    worksheet6.set_columns_level("C:F", 2)?;
    worksheet6.set_columns_level("D:E", 3)?;
    worksheet6.hide_columns("D:E")?;
    worksheet6.collapse_columns("D:E")?;
    worksheet6.write_column("A2", &["North", "South", "East", "East"])?;
    worksheet6.write_row("B2", &[50, 20, 15, 25, 65, 80])?;
    worksheet6.write_row("B3", &[10, 20, 30, 50, 50, 50])?;
    worksheet6.write_row("B4", &[45, 75, 50, 15, 75, 100])?;
    worksheet6.write_row("B5", &[15, 15, 55, 35, 20, 50])?;
    worksheet6.write_formula("H2", "=SUM(B2:G2)")?;
    worksheet6.write_formula("H3", "=SUM(B3:G3)")?;
    worksheet6.write_formula("H4", "=SUM(B4:G4)")?;
    worksheet6.write_formula("H5", "=SUM(B5:G5)")?;
    worksheet6.write_formula_with_format("H6", "=SUM(H2:H5)", &bold)?;


    workbook.save_as("examples/outline_collapsed.xlsx")?;
    Ok(())
}

examples/outline.rs (line 6)

fn main() -> WorkbookResult<()> {
    // Create a new workbook
    let mut workbook = Workbook::new();
    let worksheet1 = workbook.add_worksheet_by_name("Outlined Rows")?;
    // Add a general format
    let bold = Format::default().set_bold();

    //
    // Example 1: A worksheet with outlined rows. It also includes SUBTOTAL()?;    // functions so that it looks like the type of automatic outlines that are
    // generated when you use the Excel Data->SubTotals menu item.
    //
    // For outlines the important parameters are 'level' and 'hidden'. Rows with
    // the same 'level' are grouped together. The group will be collapsed if
    // 'hidden' is enabled. The parameters 'height' and 'cell_format' are assigned
    // default values if they are None.
    //
    worksheet1.set_row_level(2, 2)?;
    worksheet1.set_row_level(3, 2)?;
    worksheet1.set_row_level(4, 2)?;
    worksheet1.set_row_level(5, 2)?;
    worksheet1.set_row_level(6, 1)?;
    worksheet1.set_row_level(7, 2)?;
    worksheet1.set_row_level(8, 2)?;
    worksheet1.set_row_level(9, 2)?;
    worksheet1.set_row_level(10, 2)?;
    worksheet1.set_row_level(11, 1)?;

    // Adjust the column width for clarity
    worksheet1.set_columns_width("A:A", 20.0)?;

    // Add the data, labels and formulas
    worksheet1.write_with_format("A1", "Region", &bold)?;
    worksheet1.write("A2", "North")?;
    worksheet1.write("A3", "North")?;
    worksheet1.write("A4", "North")?;
    worksheet1.write("A5", "North")?;
    worksheet1.write_with_format("A6", "North Total", &bold)?;

    worksheet1.write_with_format("B1", "Sales", &bold)?;
    worksheet1.write("B2", 1000)?;
    worksheet1.write("B3", 1200)?;
    worksheet1.write("B4", 900)?;
    worksheet1.write("B5", 1200)?;
    worksheet1.write_formula_with_format("B6", "=SUBTOTAL(9,B2:B5)", &bold)?;
    worksheet1.write("A7", "South")?;
    worksheet1.write("A8", "South")?;
    worksheet1.write("A9", "South")?;
    worksheet1.write("A10", "South")?;
    worksheet1.write_with_format("A11", "South Total", &bold)?;
    worksheet1.write("B7", 400)?;
    worksheet1.write("B8", 600)?;
    worksheet1.write("B9", 500)?;
    worksheet1.write("B10", 600)?;
    worksheet1.write_formula_with_format("B11", "=SUBTOTAL(9,B7:B10)", &bold)?;
    worksheet1.write_with_format("A12", "Grand Total", &bold)?;
    worksheet1.write_formula_with_format("B12", "=SUBTOTAL(9,B2:B10)", &bold)?;


    //
    // Example 2: A worksheet with outlined rows. This is the same as the
    // previous example except that the rows are collapsed.
    // Note: We need to indicate the rows that contains the collapsed symbol '+'
    // with the optional parameter, 'collapsed'. The group will be then be
    // collapsed if 'hidden' is True.
    //
    let worksheet2 = workbook.add_worksheet_by_name("Collapsed Rows")?;
    worksheet2.set_row_level(2, 2)?;
    worksheet2.hide_row(2)?;
    worksheet2.set_row_level(3, 2)?;
    worksheet2.hide_row(3)?;
    worksheet2.set_row_level(4, 2)?;
    worksheet2.hide_row(4)?;
    worksheet2.set_row_level(5, 2)?;
    worksheet2.hide_row(5)?;
    worksheet2.set_row_level(6, 1)?;
    worksheet2.hide_row(6)?;
    worksheet2.set_row_level(7, 2)?;
    worksheet2.hide_row(7)?;
    worksheet2.set_row_level(8, 2)?;
    worksheet2.hide_row(8)?;
    worksheet2.set_row_level(9, 2)?;
    worksheet2.hide_row(9)?;
    worksheet2.set_row_level(10, 2)?;
    worksheet2.hide_row(10)?;
    worksheet2.set_row_level(11, 1)?;
    worksheet2.hide_row(11)?;
    worksheet2.collapse_row(12)?;

    // Adjust the column width for clarity
    worksheet2.set_columns_width("A:A", 20.0)?;

    // Add the data, labels and formulas
    worksheet2.write_with_format("A1", "Region", &bold)?;
    worksheet2.write("A2", "North")?;
    worksheet2.write("A3", "North")?;
    worksheet2.write("A4", "North")?;
    worksheet2.write("A5", "North")?;
    worksheet2.write_with_format("A6", "North Total", &bold)?;

    worksheet2.write_with_format("B1", "Sales", &bold)?;
    worksheet2.write("B2", 1000)?;
    worksheet2.write("B3", 1200)?;
    worksheet2.write("B4", 900)?;
    worksheet2.write("B5", 1200)?;
    worksheet2.write_formula_with_format("B6", "=SUBTOTAL(9,B2:B5)", &bold)?;
    worksheet2.write("A7", "South")?;
    worksheet2.write("A8", "South")?;
    worksheet2.write("A9", "South")?;
    worksheet2.write("A10", "South")?;
    worksheet2.write_with_format("A11", "South Total", &bold)?;
    worksheet2.write("B7", 400)?;
    worksheet2.write("B8", 600)?;
    worksheet2.write("B9", 500)?;
    worksheet2.write("B10", 600)?;
    worksheet2.write_formula_with_format("B11", "=SUBTOTAL(9,B7:B10)", &bold)?;
    worksheet2.write_with_format("A12", "Grand Total", &bold)?;
    worksheet2.write_formula_with_format("B12", "=SUBTOTAL(9,B2:B10)", &bold)?;

    //
    // Example 3: Create a worksheet with outlined columns.
    //
    let worksheet3 = workbook.add_worksheet_by_name("Outline Columns")?;
    // Add bold format to the first row.
    worksheet3.set_row_height_with_format(1, 15.0, &bold)?;
    worksheet3.write_row("A1", &["Month", "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Total"])?;
    worksheet3.set_columns_width_with_format("A:A", 10.0, &bold)?;
    worksheet3.set_columns_width("B:G", 10.0)?;
    worksheet3.set_columns_level("B:G", 1)?;
    worksheet3.set_columns_width("H:H", 10.0)?;
    worksheet3.write_column("A2", &["North", "South", "East", "East"])?;
    worksheet3.write_row("B2", &[50, 20, 15, 25, 65, 80])?;
    worksheet3.write_row("B3", &[10, 20, 30, 50, 50, 50])?;
    worksheet3.write_row("B4", &[45, 75, 50, 15, 75, 100])?;
    worksheet3.write_row("B5", &[15, 15, 55, 35, 20, 50])?;
    worksheet3.write_formula("H2", "=SUM(B2:G2)")?;
    worksheet3.write_formula("H3", "=SUM(B3:G3)")?;
    worksheet3.write_formula("H4", "=SUM(B4:G4)")?;
    worksheet3.write_formula("H5", "=SUM(B5:G5)")?;
    worksheet3.write_formula_with_format("H6", "=SUM(H2:H5)", &bold)?;

    //
    // Example 4: Show all possible outline levels.
    //
    let levels = [
        "Level 1",
        "Level 2",
        "Level 3",
        "Level 4",
        "Level 5",
        "Level 6",
        "Level 7",
        "Level 6",
        "Level 5",
        "Level 4",
        "Level 3",
        "Level 2",
        "Level 1",
    ];
    let worksheet4 = workbook.add_worksheet_by_name("Outline levels")?;
    worksheet4.write_column("A1", &levels)?;

    worksheet4.set_row_level(1, 1)?;
    worksheet4.set_row_level(2, 2)?;
    worksheet4.set_row_level(3, 3)?;
    worksheet4.set_row_level(4, 4)?;
    worksheet4.set_row_level(5, 5)?;
    worksheet4.set_row_level(6, 6)?;
    worksheet4.set_row_level(7, 7)?;
    worksheet4.set_row_level(8, 6)?;
    worksheet4.set_row_level(9, 5)?;
    worksheet4.set_row_level(10, 4)?;
    worksheet4.set_row_level(11, 3)?;
    worksheet4.set_row_level(12, 2)?;
    worksheet4.set_row_level(13, 1)?;

    workbook.save_as("examples/outline.xlsx")?;
    Ok(())
}

examples/dynamic_arrays.rs (line 16)

fn main() -> WorkbookResult<()> {
    // Create a new workbook called simple.xls and add some worksheets.
    let mut workbook = Workbook::new();
    let header1 = Format::default()
        .set_color(FormatColor::RGB(255, 255, 255))
        .set_background_color(FormatColor::RGB(74, 196, 12));
    let header2 = Format::default()
        .set_color(FormatColor::RGB(255, 255, 255))
        .set_background_color(FormatColor::RGB(40, 253, 3));

    //
    // Example of using the FILTER() function.
    //
    let worksheet1 = workbook.add_worksheet_by_name("Filter")?;
    worksheet1.write_formula("F2", "_xlfn.FILTER(A1:D17,C1:C17=K2)")?;

    // Write the data the function will work on.
    worksheet1.write_with_format("K1", "Product", &header2)?;
    worksheet1.write("K2", "Apple")?;
    worksheet1.write_with_format("F1", "Region", &header2)?;
    worksheet1.write_with_format("G1", "Sales Rep", &header2)?;
    worksheet1.write_with_format("H1", "Product", &header2)?;
    worksheet1.write_with_format("I1", "Units", &header2)?;

    write_worksheet_data(worksheet1, &header1)?;
    worksheet1.set_columns_width_pixels("E:E", 10.0)?;
    worksheet1.set_columns_width_pixels("J:J", 10.0)?;

    //
    // Example of using the UNIQUE() function.
    //
    let worksheet2 = workbook.add_worksheet_by_name("Unique")?;
    worksheet2.write_formula("F2", "_xlfn.UNIQUE(B2:B17)")?;

    // A more complex example combining SORT and UNIQUE.
    worksheet2.write_formula("H2", "_xlfn.SORT(_xlfn.UNIQUE(B2:B17))")?;

    // Write the data the function will work on.
    worksheet2.write_with_format("F1", "Sales Rep", &header2)?;
    worksheet2.write_with_format("H1", "Sales Rep", &header2)?;

    write_worksheet_data(worksheet2, &header1)?;
    worksheet2.set_columns_width_pixels("E:E", 10.0)?;
    worksheet2.set_columns_width_pixels("G:G", 10.0)?;

    //
    // Example of using the SORT() function.
    //
    let worksheet3 = workbook.add_worksheet_by_name("Sort")?;
    worksheet3.write_formula("F2", "_xlfn.SORT(B2:B17)")?;

    // A more complex example combining SORT and FILTER.
    worksheet3.write_formula("H2", "_xlfn.SORT(_xlfn.FILTER(C2: D17, D2: D17 > 5000, \"\"), 2, 1)")?;

    // Write the data the function will work on.
    worksheet3.write_with_format("F1", "Sales Rep", &header2)?;
    worksheet3.write_with_format("H1", "Product", &header2)?;
    worksheet3.write_with_format("I1", "Units", &header2)?;

    write_worksheet_data(worksheet3, &header1)?;
    worksheet3.set_columns_width_pixels("E:E", 10.0)?;
    worksheet3.set_columns_width_pixels("G:G", 10.0)?;


    //
    // Example of using the SORTBY() function.
    //
    let worksheet4 = workbook.add_worksheet_by_name("Sortby")?;
    worksheet4.write_formula("D2", "_xlfn.SORTBY(A2:B9,B2:B9)")?;

    // Write the data the function will work on.
    worksheet4.write_with_format("A1", "Name", &header1)?;
    worksheet4.write_with_format("B1", "Age", &header1)?;

    worksheet4.write("A2", "Tom")?;
    worksheet4.write("A3", "Fred")?;
    worksheet4.write("A4", "Amy")?;
    worksheet4.write("A5", "Sal")?;
    worksheet4.write("A6", "Fritz")?;
    worksheet4.write("A7", "Srivan")?;
    worksheet4.write("A8", "Xi")?;
    worksheet4.write("A9", "Hector")?;

    worksheet4.write("B2", 52)?;
    worksheet4.write("B3", 65)?;
    worksheet4.write("B4", 22)?;
    worksheet4.write("B5", 73)?;
    worksheet4.write("B6", 19)?;
    worksheet4.write("B7", 39)?;
    worksheet4.write("B8", 19)?;
    worksheet4.write("B9", 66)?;

    worksheet4.write_with_format("D1", "Name", &header2)?;
    worksheet4.write_with_format("E1", "Age", &header2)?;

    worksheet4.set_columns_width_pixels("C:C", 10.0)?;

    //
    // Example of using the XLOOKUP() function.
    //
    let worksheet5 = workbook.add_worksheet_by_name("Xlookup")?;
    worksheet5.write_formula("F1", "_xlfn.XLOOKUP(E1,A2:A9,C2:C9)")?;

    // Write the data the function will work on.
    worksheet5.write_with_format("A1", "Country", &header1)?;
    worksheet5.write_with_format("B1", "Abr", &header1)?;
    worksheet5.write_with_format("C1", "Prefix", &header1)?;

    worksheet5.write("A2", "China")?;
    worksheet5.write("A3", "India")?;
    worksheet5.write("A4", "United States")?;
    worksheet5.write("A5", "Indonesia")?;
    worksheet5.write("A6", "Brazil")?;
    worksheet5.write("A7", "Pakistan")?;
    worksheet5.write("A8", "Nigeria")?;
    worksheet5.write("A9", "Bangladesh")?;

    worksheet5.write("B2", "CN")?;
    worksheet5.write("B3", "IN")?;
    worksheet5.write("B4", "US")?;
    worksheet5.write("B5", "ID")?;
    worksheet5.write("B6", "BR")?;
    worksheet5.write("B7", "PK")?;
    worksheet5.write("B8", "NG")?;
    worksheet5.write("B9", "BD")?;

    worksheet5.write("C2", 86)?;
    worksheet5.write("C3", 91)?;
    worksheet5.write("C4", 1)?;
    worksheet5.write("C5", 62)?;
    worksheet5.write("C6", 55)?;
    worksheet5.write("C7", 92)?;
    worksheet5.write("C8", 234)?;
    worksheet5.write("C9", 880)?;

    worksheet5.write_with_format("E1", "Brazil", &header2)?;

    worksheet5.set_columns_width_pixels("A:A", 100.0)?;
    worksheet5.set_columns_width_pixels("D:D", 10.0)?;

    //
    // Example of using the XMATCH() function.
    //
    let worksheet6 = workbook.add_worksheet_by_name("Xmatch")?;
    worksheet6.write_formula("D2", "_xlfn.XMATCH(C2,A2:A6)")?;

    // Write the data the function will work on.
    worksheet6.write_with_format("A1", "Product", &header1)?;

    worksheet6.write("A2", "Apple")?;
    worksheet6.write("A3", "Grape")?;
    worksheet6.write("A4", "Pear")?;
    worksheet6.write("A5", "Banana")?;
    worksheet6.write("A6", "Cherry")?;

    worksheet6.write_with_format("C1", "Product", &header2)?;
    worksheet6.write_with_format("D1", "Position", &header2)?;
    worksheet6.write("C2", "Grape")?;

    worksheet6.set_columns_width_pixels("B:B", 10.0)?;

    //
    // Example of using the RANDARRAY() function.
    //
    let worksheet7 = workbook.add_worksheet_by_name("Randarray")?;
    worksheet7.write_dynamic_array_formula("A1", "_xlfn.RANDARRAY(5,3,1,100, TRUE)")?;

    //
    // Example of using the SEQUENCE() function.
    //
    let worksheet8 = workbook.add_worksheet_by_name("Sequence")?;
    worksheet8.write_dynamic_array_formula("A1", "_xlfn.SEQUENCE(4,5)")?;

    //
    // Example of using the Spill range operator.
    //
    let worksheet9 = workbook.add_worksheet_by_name("Spill ranges")?;
    worksheet9.write_dynamic_array_formula("H2", "_xlfn.ANCHORARRAY(F2)")?;

    worksheet9.write_dynamic_array_formula("J2", "_xlfn.COUNTA(_xlfn.ANCHORARRAY(F2))")?;

    // Write the data the to work on.
    worksheet9.write_dynamic_array_formula("F2", "_xlfn.UNIQUE(B2:B17)")?;
    worksheet9.write_with_format("F1", "Unique", &header2)?;
    worksheet9.write_with_format("H1", "Spill", &header2)?;
    worksheet9.write_with_format("J1", "Spill", &header2)?;

    write_worksheet_data(worksheet9, &header1)?;
    worksheet9.set_columns_width_pixels("E:E", 10.0)?;
    worksheet9.set_columns_width_pixels("G:G", 10.0)?;
    worksheet9.set_columns_width_pixels("I:I", 10.0)?;

    //
    // Example of using dynamic ranges with older Excel functions.
    //
    let worksheet10 = workbook.add_worksheet_by_name("Older functions")?;
    worksheet10.write_dynamic_array_formula("B1", "=LEN(A1:A3)")?;

    // Write the data the to work on.
    worksheet10.write("A1", "Foo")?;
    worksheet10.write("A2", "Food")?;
    worksheet10.write("A3", "Frood")?;


    workbook.save_as("examples/dynamic_arrays.xlsx")?;
    Ok(())
}

pub fn duplicate_worksheet(&mut self, id: u32) -> WorkbookResult<&mut WorkSheet>

Examples found in repository

examples/duplicate_sheet.rs (line 16)

fn main() -> WorkbookResult<()> {
    // from an existed workbook
    let mut workbook = Workbook::from_path("examples/xlsx/accounting.xlsx")?;
    // Use the first worksheet as a template
    let template = workbook.get_worksheet_mut(1)?;
    template.insert_image("I1:L3", &"./examples/pics/ferris.png");
    template.set_name("template")?;
    // Deselect and hide the template.
    template.deselect();
    template.hide();
    //
    // Example of using the duplicate_worksheet() function.
    //
    let jan = workbook.duplicate_worksheet(1)?;
    jan.write("A1", "Accounting Journal in Jan.")?;
    jan.set_name("Jan.")?;
    for row in 6..=15 {
        jan.write_row((row, 3), &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10])?;
    }
    let feb = workbook.duplicate_worksheet(1)?;
    feb.write("A1", "Accounting Journal in Feb.")?;
    feb.set_name("Feb.")?;
    for row in 6..=15 {
        feb.write_row((row, 3), &[2, 4, 6, 8, 10, 12, 14, 16, 18, 20])?;
    }
    // activate the Feb. sheet.
    feb.activate();
    // duplicate worksheet by sheet name
    let mar = workbook.duplicate_worksheet_by_name("template")?;
    mar.write("A1", "Accounting Journal in Mar.")?;
    mar.set_name("Mar.")?;
    for col in 'C'..='L' {
        mar.write_column(&format!("{col}6"), &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10])?;
    }
    workbook.save_as("examples/duplicate_sheet.xlsx")?;
    Ok(())
}

pub fn duplicate_worksheet_by_name( &mut self, name: &str, ) -> WorkbookResult<&mut WorkSheet>

Examples found in repository

examples/duplicate_sheet.rs (line 31)

fn main() -> WorkbookResult<()> {
    // from an existed workbook
    let mut workbook = Workbook::from_path("examples/xlsx/accounting.xlsx")?;
    // Use the first worksheet as a template
    let template = workbook.get_worksheet_mut(1)?;
    template.insert_image("I1:L3", &"./examples/pics/ferris.png");
    template.set_name("template")?;
    // Deselect and hide the template.
    template.deselect();
    template.hide();
    //
    // Example of using the duplicate_worksheet() function.
    //
    let jan = workbook.duplicate_worksheet(1)?;
    jan.write("A1", "Accounting Journal in Jan.")?;
    jan.set_name("Jan.")?;
    for row in 6..=15 {
        jan.write_row((row, 3), &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10])?;
    }
    let feb = workbook.duplicate_worksheet(1)?;
    feb.write("A1", "Accounting Journal in Feb.")?;
    feb.set_name("Feb.")?;
    for row in 6..=15 {
        feb.write_row((row, 3), &[2, 4, 6, 8, 10, 12, 14, 16, 18, 20])?;
    }
    // activate the Feb. sheet.
    feb.activate();
    // duplicate worksheet by sheet name
    let mar = workbook.duplicate_worksheet_by_name("template")?;
    mar.write("A1", "Accounting Journal in Mar.")?;
    mar.set_name("Mar.")?;
    for col in 'C'..='L' {
        mar.write_column(&format!("{col}6"), &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10])?;
    }
    workbook.save_as("examples/duplicate_sheet.xlsx")?;
    Ok(())
}

pub fn set_size(&mut self, width: u32, height: u32) -> WorkbookResult<()>

pub fn set_tab_ratio(&mut self, tab_ratio: f64) -> WorkbookResult<()>

pub fn define_name(&mut self, name: &str, value: &str) -> WorkbookResult<()>

Examples found in repository

examples/lambda.rs (line 29)

fn main() -> WorkbookResult<()> {
    // Create a new workbook
    let mut workbook = Workbook::new();
    let worksheet = workbook.get_worksheet_mut(1)?;


    // Write a Lambda function to convert Fahrenheit to Celsius to a cell.
    //
    // Note that the lambda function parameters must be prefixed with
    // "_xlpm.". These prefixes won't show up in Excel.
    worksheet.write_formula("A1", "_xlfn.LAMBDA(_xlpm.a, _xlpm.b, SQRT((_xlpm.a^2+_xlpm.b^2)))(3, 4)")?;


    // The user defined name needs to be written explicitly as a dynamic array
    // formula.
    let a = 6;
    let b = 8;
    worksheet.write_formula("A2", &format!("=HYPOTENUSE({a}, {b})"))?;

    // Create the same formula (without an argument) as a defined name and use that
    // to calculate a value.
    //
    // Note that the formula name is prefixed with "_xlfn." (this is normally
    // converted automatically by write_formula() but isn't for defined names)
    // and note that the lambda function parameters are prefixed with
    // "_xlpm.". These prefixes won't show up in Excel.
    workbook.define_name("HYPOTENUSE", "_xlfn.LAMBDA(_xlpm.a, _xlpm.b, SQRT((_xlpm.a^2+_xlpm.b^2)))")?;


    workbook.save_as("examples/lambda.xlsx")?;
    Ok(())
}

examples/defined_name.rs (line 9)

fn main() -> WorkbookResult<()> {
    // Create a new workbook
    let mut workbook = Workbook::new();
    workbook.add_worksheet()?;

    // Define some global/workbook names.
    workbook.define_name("Exchange_rate", "0.96")?;
    workbook.define_name("Sales", "Sheet1!$G$1:$H$10")?;
    // Define a local/worksheet name. Over-rides the "Sales" name above.
    workbook.define_local_name("Sales", "Sheet2!$G$1:$G$10", 2)?;

    // Write some text in the file and one of the defined names in a formula.
    let sales = ["Apple", "Grape", "Pear", "Banana", "Apple", "Grape", "Pear", "Banana", "Banana", "Pear"];
    let units = [10, 12, 32, 16, 13, 50, 25, 8, 33, 95];
    for worksheet in workbook.worksheets_mut() {
        worksheet.set_columns_width("A:B", 40.0)?;
        worksheet.set_columns_width("F:F", 40.0)?;
        worksheet.write("A1", "This worksheet contains some defined names.")?;
        worksheet.write("B1", "Show defined name Sales on the right->")?;
        worksheet.write_formula("C1", "=Sales")?;
        // In older versions of Excel, you could use the write_old_formula method:
        // worksheet.write_old_formula("C1", "=Sales")?;
        worksheet.write("A2", "See Formulas -> Name Manager above.")?;
        worksheet.write("A3", "Example formula in cell B3 ->")?;
        worksheet.write_formula("B3", "=Exchange_rate")?;
        // In older versions of Excel, you could use the write_old_formula method:
        // worksheet.write_old_formula("B3", "=Exchange_rate")?;
        worksheet.write("F1", "Fill in some arrays on the right->")?;
        worksheet.write_column("G1", &sales)?;
        worksheet.write_column("H1", &units)?;
    }

    workbook.save_as("examples/defined_name.xlsx")?;
    Ok(())
}

pub fn define_local_name( &mut self, name: &str, value: &str, sheet_id: u32, ) -> WorkbookResult<()>

Examples found in repository

examples/defined_name.rs (line 12)

fn main() -> WorkbookResult<()> {
    // Create a new workbook
    let mut workbook = Workbook::new();
    workbook.add_worksheet()?;

    // Define some global/workbook names.
    workbook.define_name("Exchange_rate", "0.96")?;
    workbook.define_name("Sales", "Sheet1!$G$1:$H$10")?;
    // Define a local/worksheet name. Over-rides the "Sales" name above.
    workbook.define_local_name("Sales", "Sheet2!$G$1:$G$10", 2)?;

    // Write some text in the file and one of the defined names in a formula.
    let sales = ["Apple", "Grape", "Pear", "Banana", "Apple", "Grape", "Pear", "Banana", "Banana", "Pear"];
    let units = [10, 12, 32, 16, 13, 50, 25, 8, 33, 95];
    for worksheet in workbook.worksheets_mut() {
        worksheet.set_columns_width("A:B", 40.0)?;
        worksheet.set_columns_width("F:F", 40.0)?;
        worksheet.write("A1", "This worksheet contains some defined names.")?;
        worksheet.write("B1", "Show defined name Sales on the right->")?;
        worksheet.write_formula("C1", "=Sales")?;
        // In older versions of Excel, you could use the write_old_formula method:
        // worksheet.write_old_formula("C1", "=Sales")?;
        worksheet.write("A2", "See Formulas -> Name Manager above.")?;
        worksheet.write("A3", "Example formula in cell B3 ->")?;
        worksheet.write_formula("B3", "=Exchange_rate")?;
        // In older versions of Excel, you could use the write_old_formula method:
        // worksheet.write_old_formula("B3", "=Exchange_rate")?;
        worksheet.write("F1", "Fill in some arrays on the right->")?;
        worksheet.write_column("G1", &sales)?;
        worksheet.write_column("H1", &units)?;
    }

    workbook.save_as("examples/defined_name.xlsx")?;
    Ok(())
}

pub fn get_defined_name(&self, name: &str) -> WorkbookResult<String>

Get the Range Reference for the given Workbook-level Name (if found)

pub fn get_defined_local_name( &self, name: &str, sheet_id: u32, ) -> WorkbookResult<String>

Get the Range Reference for the given Worksheet-level Name (if found)

pub fn worksheets_mut(&mut self) -> IterMut<'_, WorkSheet>

Examples found in repository

examples/defined_name.rs (line 17)

fn main() -> WorkbookResult<()> {
    // Create a new workbook
    let mut workbook = Workbook::new();
    workbook.add_worksheet()?;

    // Define some global/workbook names.
    workbook.define_name("Exchange_rate", "0.96")?;
    workbook.define_name("Sales", "Sheet1!$G$1:$H$10")?;
    // Define a local/worksheet name. Over-rides the "Sales" name above.
    workbook.define_local_name("Sales", "Sheet2!$G$1:$G$10", 2)?;

    // Write some text in the file and one of the defined names in a formula.
    let sales = ["Apple", "Grape", "Pear", "Banana", "Apple", "Grape", "Pear", "Banana", "Banana", "Pear"];
    let units = [10, 12, 32, 16, 13, 50, 25, 8, 33, 95];
    for worksheet in workbook.worksheets_mut() {
        worksheet.set_columns_width("A:B", 40.0)?;
        worksheet.set_columns_width("F:F", 40.0)?;
        worksheet.write("A1", "This worksheet contains some defined names.")?;
        worksheet.write("B1", "Show defined name Sales on the right->")?;
        worksheet.write_formula("C1", "=Sales")?;
        // In older versions of Excel, you could use the write_old_formula method:
        // worksheet.write_old_formula("C1", "=Sales")?;
        worksheet.write("A2", "See Formulas -> Name Manager above.")?;
        worksheet.write("A3", "Example formula in cell B3 ->")?;
        worksheet.write_formula("B3", "=Exchange_rate")?;
        // In older versions of Excel, you could use the write_old_formula method:
        // worksheet.write_old_formula("B3", "=Exchange_rate")?;
        worksheet.write("F1", "Fill in some arrays on the right->")?;
        worksheet.write_column("G1", &sales)?;
        worksheet.write_column("H1", &units)?;
    }

    workbook.save_as("examples/defined_name.xlsx")?;
    Ok(())
}

examples/autofilter.rs (line 23)

fn main() -> WorkbookResult<()> {
    // Prepare autofilter data
    let text = fs::read_to_string("examples/autofilter_data.txt").unwrap();
    let mut text = text.split("\n");
    let headers: Vec<&str> = text.next().unwrap().split_whitespace().collect();
    let mut data: Vec<Vec<&str>> = vec![];
    for text in text { data.push(text.split_whitespace().collect()) }

    // Create a new workbook
    let mut workbook = Workbook::new();
    // Add some worksheets
    workbook.add_worksheet()?;
    workbook.add_worksheet()?;
    workbook.add_worksheet()?;
    workbook.add_worksheet()?;
    workbook.add_worksheet()?;
    workbook.add_worksheet()?;

    // Set up several sheets with the same data.
    for worksheet in workbook.worksheets_mut() {
        // Make the columns wider.
        worksheet.set_columns_width("A:D", 12.0)?;
        // // Make the header row larger.
        worksheet.set_row_height_with_format(1, 20.0, &Format::default().set_bold())?;
        // Make the headers bold.
        worksheet.write_row("A1", &headers)?;
    }

    //
    // Example 1. Autofilter without conditions.
    //

    let worksheet1 = workbook.get_worksheet_mut(1)?;
    // Set the autofilter.
    worksheet1.autofilter("A1:D51");
    let mut row = 2;
    for row_data in &data {
        let mut col = 1;
        for data in row_data {
            if let Ok(num) = data.parse::<i32>() {
                worksheet1.write((row, col), num)?;
            } else {
                worksheet1.write((row, col), *data)?;
            }
            col += 1;
        }
        // Move on to the next worksheet row.
        row += 1;
    }


    //
    // Example 2. Autofilter with a filter condition in the first column.
    //
    let worksheet2 = workbook.get_worksheet_mut(2)?;
    // Set the autofilter.
    worksheet2.autofilter("A1:D51");
    // Add filter criteria.
    let mut filters = Filters::new();
    filters.and(Filter::eq("East"));
    worksheet2.filter_column("A", &filters);
    // Hide the rows that don't match the filter criteria.
    let mut row = 2;
    for row_data in &data {
        let mut col = 1;
        let data = row_data.get(0);
        // Check for rows that match the filter.
        if data != Some(&"East") {
            // We need to hide rows that don't match the filter.
            worksheet2.hide_row(row)?;
        }
        for data in row_data {
            if let Ok(num) = data.parse::<i32>() {
                worksheet2.write((row, col), num)?;
            } else {
                worksheet2.write((row, col), *data)?;
            }
            col += 1;
        }
        // Move on to the next worksheet row.
        row += 1;
    }

    //
    // Example 3. Autofilter with a filter condition in the first column.
    //
    let worksheet3 = workbook.get_worksheet_mut(3)?;
    // Set the autofilter.
    worksheet3.autofilter("A1:D51");
    // Add filter criteria.
    let mut filters = Filters::new();
    filters.and(Filter::eq("East")).or(Filter::eq("South"));
    worksheet3.filter_column("A", &filters);
    // Hide the rows that don't match the filter criteria.
    let mut row = 2;
    for row_data in &data {
        let mut col = 1;
        let data = row_data.get(0);
        // Check for rows that match the filter.
        if data != Some(&"East") && data != Some(&"South") {
            // We need to hide rows that don't match the filter.
            worksheet3.hide_row(row)?;
        }
        for data in row_data {
            if let Ok(num) = data.parse::<i32>() {
                worksheet3.write((row, col), num)?;
            } else {
                worksheet3.write((row, col), *data)?;
            }
            col += 1;
        }
        // Move on to the next worksheet row.
        row += 1;
    }


    //
    // Example 4. Autofilter with filter conditions in two columns.
    //
    let worksheet4 = workbook.get_worksheet_mut(4)?;
    // Set the autofilter.
    worksheet4.autofilter("A1:D51");
    // Add filter criteria.
    let mut filters_a = Filters::new();
    filters_a.and(Filter::eq("East"));
    worksheet4.filter_column("A", &filters_a);
    let mut filters_c = Filters::new();
    filters_c.and(Filter::gt("3000")).and(Filter::lt("8000"));
    worksheet4.filter_column("C", &filters_c);
    // Hide the rows that don't match the filter criteria.
    let mut row = 2;
    for row_data in &data {
        let mut col = 1;
        let data = row_data.get(0);
        // Check for rows that match the filter.
        if data != Some(&"East") {
            // We need to hide rows that don't match the filter.
            worksheet4.hide_row(row)?;
        }
        for data in row_data {
            if let Ok(num) = data.parse::<i32>() {
                if num <= 3000 || num >= 8000 {
                    worksheet4.hide_row(row)?;
                }
                worksheet4.write((row, col), num)?;
            } else {
                worksheet4.write((row, col), *data)?;
            }
            col += 1;
        }
        // Move on to the next worksheet row.
        row += 1;
    }


    //
    // Example 5. Autofilter with a filter list condition in one of the columns.
    //
    let worksheet5 = workbook.get_worksheet_mut(5)?;
    // Set the autofilter.
    worksheet5.autofilter("A1:D51");
    // Add filter criteria.
    let filters_list = Filters::eq(vec!["East", "North", "South"]);
    worksheet5.filter_column("A", &filters_list);
    // Hide the rows that don't match the filter criteria.
    let mut row = 2;
    for row_data in &data {
        let mut col = 1;
        let data = row_data.get(0);
        // Check for rows that match the filter.
        if data != Some(&"East") && data != Some(&"North") && data != Some(&"South") {
            // We need to hide rows that don't match the filter.
            worksheet5.hide_row(row)?;
        }
        for data in row_data {
            if let Ok(num) = data.parse::<i32>() {
                worksheet5.write((row, col), num)?;
            } else {
                worksheet5.write((row, col), *data)?;
            }
            col += 1;
        }
        // Move on to the next worksheet row.
        row += 1;
    }

    //
    // Example 6. Autofilter with filter for blanks.
    //
    let worksheet6 = workbook.get_worksheet_mut(6)?;
    // Set the autofilter.
    worksheet6.autofilter("A1:D51");
    // Add filter criteria.
    let filters = Filters::blank();
    worksheet6.filter_column("A", &filters);
    // Hide the rows that don't match the filter criteria.
    let mut row = 2;
    // Simulate a blank cell in the data.
    data[5][0] = "";

    for row_data in &data {
        let mut col = 1;
        let data = row_data.get(0);
        // Check for rows that match the filter.
        if data != Some(&"") {
            // We need to hide rows that don't match the filter.
            worksheet6.hide_row(row)?;
        }
        for data in row_data {
            if let Ok(num) = data.parse::<i32>() {
                worksheet6.write((row, col), num)?;
            } else {
                worksheet6.write((row, col), *data)?;
            }
            col += 1;
        }
        // Move on to the next worksheet row.
        row += 1;
    }

    //
    // Example 7. Autofilter with filter for non-blanks.
    //
    let worksheet7 = workbook.get_worksheet_mut(7)?;
    // Set the autofilter.
    worksheet7.autofilter("A1:D51");
    // Add filter criteria.
    let filters = Filters::not_blank();
    worksheet7.filter_column("A", &filters);
    // Hide the rows that don't match the filter criteria.
    let mut row = 2;
    // Simulate a blank cell in the data.

    for row_data in &data {
        let mut col = 1;
        let data = row_data.get(0);
        // Check for rows that match the filter.
        if data == Some(&"") {
            // We need to hide rows that don't match the filter.
            worksheet7.hide_row(row)?;
        }
        for data in row_data {
            if let Ok(num) = data.parse::<i32>() {
                worksheet7.write((row, col), num)?;
            } else {
                worksheet7.write((row, col), *data)?;
            }
            col += 1;
        }
        // Move on to the next worksheet row.
        row += 1;
    }


    workbook.save_as("examples/autofilter.xlsx")?;

    Ok(())
}

pub fn worksheets(&self) -> Iter<'_, WorkSheet>

pub fn read_only_recommended(&mut self) -> WorkbookResult<()>

pub fn set_properties( &mut self, properties: &Properties<'_>, ) -> WorkbookResult<()>

Examples found in repository

examples/doc_properties.rs (line 16)

fn main() -> WorkbookResult<()> {
    // Create a new workbook
    let mut workbook = Workbook::new();
    let mut properties = Properties::default();
    properties.set_title("This is an example spreadsheet")
        .set_subject("With document properties")
        .set_author("pt")
        .set_manager("example manager")
        .set_company("example company")
        .set_category("Example spreadsheets")
        .set_keywords("Sample, Example, Properties")
        .set_comments("Created with Rust")
        .set_status("example status");
    workbook.set_properties(&properties)?;
    // Use the default worksheet
    let worksheet = workbook.get_worksheet_mut(1)?;
    worksheet.set_columns_width("A:A", 70.0)?;
    worksheet.write("A1", "Select 'Workbook Properties' to see properties.")?;
    workbook.save_as("examples/doc_properties.xlsx")?;
    Ok(())
}

impl Workbook

pub fn from_path<P: AsRef<Path>>(file_path: P) -> WorkbookResult<Workbook>

Examples found in repository

examples/duplicate_sheet.rs (line 5)

fn main() -> WorkbookResult<()> {
    // from an existed workbook
    let mut workbook = Workbook::from_path("examples/xlsx/accounting.xlsx")?;
    // Use the first worksheet as a template
    let template = workbook.get_worksheet_mut(1)?;
    template.insert_image("I1:L3", &"./examples/pics/ferris.png");
    template.set_name("template")?;
    // Deselect and hide the template.
    template.deselect();
    template.hide();
    //
    // Example of using the duplicate_worksheet() function.
    //
    let jan = workbook.duplicate_worksheet(1)?;
    jan.write("A1", "Accounting Journal in Jan.")?;
    jan.set_name("Jan.")?;
    for row in 6..=15 {
        jan.write_row((row, 3), &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10])?;
    }
    let feb = workbook.duplicate_worksheet(1)?;
    feb.write("A1", "Accounting Journal in Feb.")?;
    feb.set_name("Feb.")?;
    for row in 6..=15 {
        feb.write_row((row, 3), &[2, 4, 6, 8, 10, 12, 14, 16, 18, 20])?;
    }
    // activate the Feb. sheet.
    feb.activate();
    // duplicate worksheet by sheet name
    let mar = workbook.duplicate_worksheet_by_name("template")?;
    mar.write("A1", "Accounting Journal in Mar.")?;
    mar.set_name("Mar.")?;
    for col in 'C'..='L' {
        mar.write_column(&format!("{col}6"), &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10])?;
    }
    workbook.save_as("examples/duplicate_sheet.xlsx")?;
    Ok(())
}

examples/read_and_copy.rs (line 9)

fn main() -> WorkbookResult<()> {
    // Read an existed workbook
    let reading_book = Workbook::from_path("./tests/xlsx/accounting.xlsx")?;
    let reading_sheet = reading_book.get_worksheet_by_name("worksheet")?;
    // Create a new workbook to write
    let mut writing_book = Workbook::new();
    let writing_sheet = writing_book.get_worksheet_mut(1)?;

    // Synchronous column width and format
    let columns_map = reading_sheet.get_columns_with_format("A:XFD")?;
    match reading_sheet.get_default_column() {
        None => writing_sheet.set_default_column_adaptive(),
        Some(width) => writing_sheet.set_default_column(width),
    }
    columns_map.iter().for_each(|(col_range, (column, format))| {
        if let Some(format) = format {
            // if col format exists, write it to writing_sheet
            writing_sheet.set_columns_with_format(col_range, column, format).unwrap()
        } else {
            writing_sheet.set_columns(col_range, column).unwrap()
        }
    });

    // Synchronous row height and format
    writing_sheet.set_default_row(reading_sheet.get_default_row());
    for row_number in 1..=reading_sheet.max_row() {
        let (row, format) = reading_sheet.get_row_with_format(row_number)?;
        if let Some(format) = format {
            // if col format exists, write it to writing_sheet
            writing_sheet.set_row_with_format(row_number, &row, &format)?;
        } else {
            writing_sheet.set_row(row_number, &row)?;
        }
    }

    // Read then write text and format
    for row in 1..=reading_sheet.max_row() {
        for col in 1..=reading_sheet.max_column() {
            if let Ok(cell) = reading_sheet.read_cell((row, col)) {
                writing_sheet.write_cell((row, col), &cell)?;
            }
        }
    }

    writing_book.save_as("./examples/read_and_copy.xlsx")?;
    Ok(())
}

examples/xlsx2adoc.rs (line 103)

pub fn xlsx_convert(
    in_file_name: &Path,
    out_file_name: &Path,
) -> Result<Xlsx2AdocTestResults, Error> {
    let workbook = Workbook::from_path(in_file_name);
    let mut workbook = workbook.unwrap();
    workbook.finish();

    let reading_sheet = workbook.get_worksheet(1);
    let sheet = reading_sheet.unwrap();
    let default_row_hight = sheet.get_default_row();

    println!(
        "Rows {} -> ? ( {} )",
        sheet.max_row(),
        //        formatted_row.len(),
        default_row_hight
    );

    let mut hights = Vec::<f64>::new();
    for _ in 0..sheet.max_row() {
        hights.push(default_row_hight);
    }

    let widths = find_col_width(sheet)?;
    let bounds = "|===\r";
    let line = tab_header(&widths);

    let mut output_file = File::create(out_file_name)?; // overwrites existing file
    let mut writer = BufWriter::new(&mut output_file);

    writer.write(line.as_bytes())?;
    writer.write(bounds.as_bytes())?;

    /*     // todo test
       writer.write("|1|2|3\r".as_bytes())?;
       writer.write("|4|5|6\r".as_bytes())?;

       writer.write(bounds.as_bytes())?;
    */
    for row in 0..sheet.max_row() {
        println!("Row {} ({})", row, hights[row as usize]);
        for col in 0..sheet.max_column() {
            if col < sheet.max_column() {
                writer.write("|".as_bytes())?;
            }

            let cell_content = sheet.read_cell((row + 1, col + 1)).unwrap_or_default();
            let format = cell_content.format;
            let mut text_color = FormatColor::Default;
            let mut bg_color = FormatColor::Default;
            let mut bg_bg_color = FormatColor::Default;
            if format.is_some() {
                let format = format.unwrap();
                text_color = format.get_color().clone();
                let ff = format.get_background().clone();
                bg_color = ff.fg_color.clone();
                bg_bg_color = ff.bg_color.clone();
            }

            let cell_format_string = format!(
                "Text-Color = {:?}        bg = {:?}        bg_bg = {:?}",
                text_color, bg_color, bg_bg_color
            );
            let cell_text = cell_content.text;
            let text = match cell_text {
                Some(t) => t,
                None => "-".to_owned(),
            };

            println!(
                "{} ({}) -> {}     Format: {}",
                col,
                widths[(col) as usize],
                text,
                cell_format_string
            );
            writer.write(text.as_bytes())?;
        }

        writer.write("\r".as_bytes())?;
    }
    writer.write(bounds.as_bytes())?;

    let xlsx_2_adoc_test_results = Xlsx2AdocTestResults { v1: 0, v2: 0 };
    Ok(xlsx_2_adoc_test_results)
}

pub fn save_as<P: AsRef<Path>>(&self, file_path: P) -> WorkbookResult<()>

Examples found in repository

examples/background.rs (line 12)

fn main() -> WorkbookResult<()> {
    // Create a new workbook
    let mut workbook = Workbook::new();
    // Use the default worksheet
    let worksheet = workbook.get_worksheet_mut(1)?;
    // Set the background image.
    // **NOTICE**: Only png format is acceptable in the background image
    worksheet.set_background("examples/pics/ferris.png")?;

    workbook.save_as("examples/background.xlsx")?;
    Ok(())
}

examples/image.rs (line 10)

fn main() -> WorkbookResult<()> {
    let mut workbook = Workbook::new();
    let worksheet = workbook.get_worksheet_mut(1)?;
    // 0.4.0+ Feature: Support for inserting images in the following formats:
    // jpg, png, gif, webp, tif
    worksheet.insert_image("A1:C7", &"./examples/pics/capybara.bmp")?;
    worksheet.insert_image("C7:E14", &"./examples/pics/rust.png")?;
    workbook.save_as("examples/image.xlsx")?;
    Ok(())
}

examples/tab_color.rs (line 15)

fn main() -> WorkbookResult<()> {
    // Create a new workbook
    let mut workbook = Workbook::new();
    // Set up some worksheets and set tab colors
    let worksheet1 = workbook.get_worksheet_mut(1)?;
    worksheet1.set_tab_color(&FormatColor::RGB(255, 0, 0)); // Red
    let worksheet2 = workbook.add_worksheet()?;
    worksheet2.set_tab_color(&FormatColor::Index(11)); // Green
    let worksheet3 = workbook.add_worksheet()?;
    worksheet3.set_tab_color(&FormatColor::Theme(5, 0.0)); // Orange
    let worksheet4 = workbook.add_worksheet()?;
    // worksheet4 will have the default color.
    workbook.save_as("examples/tab_color.xlsx")?;
    Ok(())
}

examples/hide_row_col.rs (line 25)

fn main() -> WorkbookResult<()> {
    // Create a new workbook
    let mut workbook = Workbook::new();

    let worksheet = workbook.get_worksheet_mut(1)?;

    // Write some data.
    worksheet.write("D1", "Some hidden columns.")?;
    worksheet.write("A8", "Some hidden rows.")?;

    // Hide all rows without data.
    worksheet.hide_unused_rows(true);

    // Set the height of empty rows that we do want to display even if it is
    // the default height.
    for row in 2..=7 {
        worksheet.set_row_height(row, 15.0)?;
    }

    // Columns can be hidden explicitly. This doesn't increase the file size..
    worksheet.hide_columns("G:XFD")?;

    workbook.save_as("examples/hide_row_col.xlsx")?;
    Ok(())
}

examples/text_indent.rs (line 20)

fn main() -> WorkbookResult<()> {
    // Create a new workbook
    let mut workbook = Workbook::new();
    let worksheet = workbook.get_worksheet_mut(1)?;

    let indent1 = Format::default().set_indent(1);
    let indent2 = Format::default().set_indent(2);

    worksheet.set_columns_width("A:A", 40.0)?;

    worksheet.write_with_format("A1", "This text is indented 1 level", &indent1)?;
    worksheet.write_with_format("A2", "This text is indented 2 levels", &indent2)?;

    // Note: Alignment is not applied correctly when changing the reading order, this bug will be fixed in the future!
    // let indent = Format::default().set_reading_order(2).set_align(FormatAlignType::Right).set_indent(2);
    // worksheet.right_to_left();

    workbook.save_as("examples/text_indent.xlsx")?;
    Ok(())
}

examples/doc_properties.rs (line 21)

fn main() -> WorkbookResult<()> {
    // Create a new workbook
    let mut workbook = Workbook::new();
    let mut properties = Properties::default();
    properties.set_title("This is an example spreadsheet")
        .set_subject("With document properties")
        .set_author("pt")
        .set_manager("example manager")
        .set_company("example company")
        .set_category("Example spreadsheets")
        .set_keywords("Sample, Example, Properties")
        .set_comments("Created with Rust")
        .set_status("example status");
    workbook.set_properties(&properties)?;
    // Use the default worksheet
    let worksheet = workbook.get_worksheet_mut(1)?;
    worksheet.set_columns_width("A:A", 70.0)?;
    worksheet.write("A1", "Select 'Workbook Properties' to see properties.")?;
    workbook.save_as("examples/doc_properties.xlsx")?;
    Ok(())
}

Additional examples can be found in:

• examples/merge.rs
• examples/array_formula.rs
• examples/hide_sheet.rs
• examples/old_array_formula.rs
• examples/lambda.rs
• examples/ignore_errors.rs
• examples/right_to_left.rs
• examples/duplicate_sheet.rs
• examples/defined_name.rs
• examples/read_and_copy.rs
• examples/hello_world.rs
• examples/panes.rs
• examples/outline_collapsed.rs
• examples/outline.rs
• examples/dynamic_arrays.rs
• examples/autofilter.rs

pub fn save(&mut self) -> WorkbookResult<()>

pub fn finish(&mut self)

Examples found in repository

examples/xlsx2adoc.rs (line 105)

pub fn xlsx_convert(
    in_file_name: &Path,
    out_file_name: &Path,
) -> Result<Xlsx2AdocTestResults, Error> {
    let workbook = Workbook::from_path(in_file_name);
    let mut workbook = workbook.unwrap();
    workbook.finish();

    let reading_sheet = workbook.get_worksheet(1);
    let sheet = reading_sheet.unwrap();
    let default_row_hight = sheet.get_default_row();

    println!(
        "Rows {} -> ? ( {} )",
        sheet.max_row(),
        //        formatted_row.len(),
        default_row_hight
    );

    let mut hights = Vec::<f64>::new();
    for _ in 0..sheet.max_row() {
        hights.push(default_row_hight);
    }

    let widths = find_col_width(sheet)?;
    let bounds = "|===\r";
    let line = tab_header(&widths);

    let mut output_file = File::create(out_file_name)?; // overwrites existing file
    let mut writer = BufWriter::new(&mut output_file);

    writer.write(line.as_bytes())?;
    writer.write(bounds.as_bytes())?;

    /*     // todo test
       writer.write("|1|2|3\r".as_bytes())?;
       writer.write("|4|5|6\r".as_bytes())?;

       writer.write(bounds.as_bytes())?;
    */
    for row in 0..sheet.max_row() {
        println!("Row {} ({})", row, hights[row as usize]);
        for col in 0..sheet.max_column() {
            if col < sheet.max_column() {
                writer.write("|".as_bytes())?;
            }

            let cell_content = sheet.read_cell((row + 1, col + 1)).unwrap_or_default();
            let format = cell_content.format;
            let mut text_color = FormatColor::Default;
            let mut bg_color = FormatColor::Default;
            let mut bg_bg_color = FormatColor::Default;
            if format.is_some() {
                let format = format.unwrap();
                text_color = format.get_color().clone();
                let ff = format.get_background().clone();
                bg_color = ff.fg_color.clone();
                bg_bg_color = ff.bg_color.clone();
            }

            let cell_format_string = format!(
                "Text-Color = {:?}        bg = {:?}        bg_bg = {:?}",
                text_color, bg_color, bg_bg_color
            );
            let cell_text = cell_content.text;
            let text = match cell_text {
                Some(t) => t,
                None => "-".to_owned(),
            };

            println!(
                "{} ({}) -> {}     Format: {}",
                col,
                widths[(col) as usize],
                text,
                cell_format_string
            );
            writer.write(text.as_bytes())?;
        }

        writer.write("\r".as_bytes())?;
    }
    writer.write(bounds.as_bytes())?;

    let xlsx_2_adoc_test_results = Xlsx2AdocTestResults { v1: 0, v2: 0 };
    Ok(xlsx_2_adoc_test_results)
}

Trait Implementations

impl Debug for Workbook

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

Formats the value using the given formatter.

impl Drop for Workbook

fn drop(&mut self)

Executes the destructor for this type.