Struct WorkSheet 

pub struct WorkSheet { /* private fields */ }

Implementations

impl WorkSheet

pub fn get_theme(&self, theme_id: u32) -> Theme

impl WorkSheet

pub fn autofilter<L: LocationRange>(&mut self, loc_range: L)

Examples found in repository

examples/autofilter.rs (line 38)

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 filter_column<L: Location>(&mut self, col: L, filters: &Filters<'_>)

Examples found in repository

examples/autofilter.rs (line 64)

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(())
}

impl WorkSheet

pub fn max_column(&self) -> u32

Examples found in repository

examples/xlsx2adoc.rs (line 71)

fn find_col_width(sheet: &WorkSheet) -> Result<Vec<f64>, Error> {
    let mut widths = Vec::<f64>::new();
    let default_col_width = sheet.get_default_column().unwrap_or(1.0);

    for _ in 0..sheet.max_column() {
        widths.push(default_col_width);
    }

    let formatted_col_result = sheet.get_columns_with_format((1, 1, 1, 16384));
    let formatted_col = match formatted_col_result {
        Ok(f) => f,
        Err(e) => return Err(error_text(&format!("{:?}", e))),
    };

    for w in formatted_col.iter() {
        let column_name = w.0;
        let a = w.1;
        let columns_specs = a.0;
        let column_width = columns_specs.width;
        match column_width {
            Some(width) => {
                let col_range = decode_col_range(column_name, widths.len());
                for c in col_range {
                    widths[c] = width;
                }
            }
            None => {},
        };
}
    Ok(widths)
}

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)
}

examples/read_and_copy.rs (line 44)

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 max_row(&self) -> u32

Examples found in repository

examples/read_and_copy.rs (line 32)

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 113)

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_name(&self) -> &str

pub fn set_name(&mut self, name: &str) -> WorkSheetResult<()>

Examples found in repository

examples/duplicate_sheet.rs (line 9)

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 activate(&mut self)

Examples found in repository

examples/duplicate_sheet.rs (line 29)

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 select(&mut self)

pub fn deselect(&mut self)

Examples found in repository

examples/duplicate_sheet.rs (line 11)

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 right_to_left(&mut self)

Examples found in repository

examples/right_to_left.rs (line 25)

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(())
}

pub fn set_top_left_cell<L: Location>(&mut self, loc: L)

pub fn set_zoom(&mut self, zoom_scale: u16)

pub fn set_selection<L: LocationRange>( &mut self, loc_range: L, ) -> WorkSheetResult<()>

Examples found in repository

examples/panes.rs (line 23)

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(())
}

pub fn freeze_panes<L: Location>(&mut self, loc: L) -> WorkSheetResult<()>

Examples found in repository

examples/panes.rs (line 19)

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(())
}

pub fn split_panes(&mut self, width: f64, height: f64) -> WorkSheetResult<()>

Examples found in repository

examples/panes.rs (line 87)

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(())
}

pub fn set_default_row(&mut self, height: f64)

Examples found in repository

examples/read_and_copy.rs (line 31)

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/panes.rs (line 86)

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(())
}

pub fn get_default_row(&self) -> f64

Examples found in repository

examples/read_and_copy.rs (line 31)

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 109)

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 set_default_column(&mut self, height: f64)

Examples found in repository

examples/read_and_copy.rs (line 19)

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 set_default_column_adaptive(&mut self)

Examples found in repository

examples/read_and_copy.rs (line 18)

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_default_column(&self) -> Option<f64>

Examples found in repository

examples/xlsx2adoc.rs (line 69)

fn find_col_width(sheet: &WorkSheet) -> Result<Vec<f64>, Error> {
    let mut widths = Vec::<f64>::new();
    let default_col_width = sheet.get_default_column().unwrap_or(1.0);

    for _ in 0..sheet.max_column() {
        widths.push(default_col_width);
    }

    let formatted_col_result = sheet.get_columns_with_format((1, 1, 1, 16384));
    let formatted_col = match formatted_col_result {
        Ok(f) => f,
        Err(e) => return Err(error_text(&format!("{:?}", e))),
    };

    for w in formatted_col.iter() {
        let column_name = w.0;
        let a = w.1;
        let columns_specs = a.0;
        let column_width = columns_specs.width;
        match column_width {
            Some(width) => {
                let col_range = decode_col_range(column_name, widths.len());
                for c in col_range {
                    widths[c] = width;
                }
            }
            None => {},
        };
}
    Ok(widths)
}

examples/read_and_copy.rs (line 17)

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 hide_unused_rows(&mut self, hide: bool)

Examples found in repository

examples/hide_row_col.rs (line 14)

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(())
}

pub fn outline_settings( &mut self, visible: bool, symbols_below: bool, symbols_right: bool, auto_style: bool, )

pub fn ignore_errors<L: Location>(&mut self, error_map: HashMap<&str, L>)

Examples found in repository

examples/ignore_errors.rs (line 23)

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

    // Write strings that looks like numbers. This will cause an Excel warning.
    worksheet.write_string("C2", "123".to_string())?;
    worksheet.write_string("C3", "123".to_string())?;

    // Write a divide by zero formula. This will also cause an Excel warning.
    worksheet.write_formula("C5", "=1/0")?;
    worksheet.write_formula("C6", "=1/0")?;
    // In older versions of Excel, you could use the write_old_formula method:
    // worksheet.write_old_formula("C5", "=1/0")?;
    // worksheet.write_old_formula("C6", "=1/0")?;

    // Turn off some of the warnings:
    let mut error_map = HashMap::new();
    error_map.insert("number_stored_as_text", "C3");
    error_map.insert("eval_error", "C6");
    worksheet.ignore_errors(error_map);

    // Write some descriptions for the cells and make the column wider for clarity.
    worksheet.set_columns_width("B:B", 16.0)?;
    worksheet.write("B2", "Warning:")?;
    worksheet.write("B3", "Warning turned off:")?;
    worksheet.write("B5", "Warning:")?;
    worksheet.write("B6", "Warning turned off:")?;

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

pub fn hide(&mut self)

Examples found in repository

examples/hide_sheet.rs (line 15)

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/duplicate_sheet.rs (line 12)

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_tab_color(&mut self, tab_color: &FormatColor)

Examples found in repository

examples/tab_color.rs (line 8)

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/hello_world.rs (line 36)

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(())
}

pub fn set_background<P: AsRef<Path>>( &mut self, filename: P, ) -> WorkSheetResult<()>

Examples found in repository

examples/background.rs (line 10)

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/hello_world.rs (line 38)

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(())
}

pub fn insert_image<L: LocationRange, P: AsRef<Path>>( &mut self, loc_range: L, filename: &P, ) -> WorkSheetResult<()>

Examples found in repository

examples/image.rs (line 8)

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/duplicate_sheet.rs (line 8)

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/hello_world.rs (line 49)

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(())
}

pub fn id(&self) -> u32

Trait Implementations

impl Debug for WorkSheet

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

Formats the value using the given formatter.

impl Read for WorkSheet

fn read_cell<L: Location>(&self, loc: L) -> WorkSheetResult<Cell<String>>

impl WorkSheetCol for WorkSheet

fn get_columns<R: LocationRange>( &self, col_range: R, ) -> WorkSheetResult<HashMap<String, Column>>

Get the Columns based on the col range, note that the col range starts with 1.

fn get_columns_with_format<R: LocationRange>( &self, col_range: R, ) -> WorkSheetResult<HashMap<String, (Column, Option<Format>)>>

Get the Columns and Formats of cols based on the col range, note that the col range starts with 1.

fn get_columns_width<R: LocationRange>( &self, col_range: R, ) -> WorkSheetResult<HashMap<String, Option<f64>>>

Get the custom width of cols based on the col range, note that the col range starts with 1.

fn set_columns<R: LocationRange>( &mut self, col_range: R, column: &Column, ) -> WorkSheetResult<()>

update columns by Column.

fn set_columns_with_format<R: LocationRange>( &mut self, col_range: R, column: &Column, format: &Format, ) -> WorkSheetResult<()>

update columns and formats by Column.

fn set_columns_width<R: LocationRange>( &mut self, col_range: R, width: f64, ) -> WorkSheetResult<()>

set the width of columns by columns range, The effect is the same as

fn set_columns_width_pixels<R: LocationRange>( &mut self, col_range: R, width: f64, ) -> WorkSheetResult<()>

fn set_columns_width_with_format<R: LocationRange>( &mut self, col_range: R, width: f64, format: &Format, ) -> WorkSheetResult<()>

set the width of columns by columns range, The effect is the same as

fn set_columns_width_pixels_with_format<R: LocationRange>( &mut self, col_range: R, width: f64, format: &Format, ) -> WorkSheetResult<()>

fn hide_columns<R: LocationRange>( &mut self, col_range: R, ) -> WorkSheetResult<()>

hide columns by column range, The effect is the same as

fn set_columns_level<R: LocationRange>( &mut self, col_range: R, level: u8, ) -> WorkSheetResult<()>

set the outline of columns by column range, The effect is the same as

fn collapse_columns<R: LocationRange>( &mut self, col_range: R, ) -> WorkSheetResult<()>

collapse columns by column range, The effect is the same as

impl WorkSheetRow for WorkSheet

fn get_row(&self, row: u32) -> WorkSheetResult<Row>

Get the Row of a row based on the row number, note that the row number starts with 1.

fn get_row_with_format( &self, row: u32, ) -> WorkSheetResult<(Row, Option<Format>)>

Get the Row and Format of a row based on the row number, note that the row number starts with 1.

fn get_row_height(&self, row: u32) -> WorkSheetResult<Option<f64>>

Get the custom height of a row based on the row number, note that the row number starts with 1. Only rows have custom height can return their height.

fn set_row(&mut self, row_number: u32, row: &Row) -> WorkSheetResult<()>

update a row by Row, note that the row number starts with 1.

fn set_row_with_format( &mut self, row_number: u32, row: &Row, format: &Format, ) -> WorkSheetResult<()>

update a row by Row, note that the row number starts with 1.

fn set_row_height(&mut self, row: u32, height: f64) -> WorkSheetResult<()>

set the height of a row by row number, The effect is the same as

fn set_row_height_pixels( &mut self, row: u32, height: f64, ) -> WorkSheetResult<()>

fn set_row_height_with_format( &mut self, row: u32, height: f64, format: &Format, ) -> WorkSheetResult<()>

set the height and format of a row by row number, The effect is the same as

fn set_row_height_pixels_with_format( &mut self, row: u32, height: f64, format: &Format, ) -> WorkSheetResult<()>

fn hide_row(&mut self, row: u32) -> WorkSheetResult<()>

hide a row by row number, The effect is the same as

fn set_row_level(&mut self, row: u32, level: u8) -> WorkSheetResult<()>

set the outline of a row by row number, The effect is the same as

fn collapse_row(&mut self, row: u32) -> WorkSheetResult<()>

collapse a row by row number, The effect is the same as

impl Write for WorkSheet

fn write_cell<L: Location, T: Clone + CellDisplay + CellValue>( &mut self, loc: L, cell: &Cell<T>, ) -> WorkSheetResult<()>

fn write<L: Location, T: Default + Clone + CellDisplay + CellValue>( &mut self, loc: L, data: T, ) -> WorkSheetResult<()>

fn write_string<L: Location>( &mut self, loc: L, data: String, ) -> WorkSheetResult<()>

fn write_rich_string<L: Location>( &mut self, loc: L, data: &RichText, ) -> WorkSheetResult<()>

fn write_number<L: Location>( &mut self, loc: L, data: i32, ) -> WorkSheetResult<()>

fn write_double<L: Location>( &mut self, loc: L, data: f64, ) -> WorkSheetResult<()>

fn write_boolean<L: Location>( &mut self, loc: L, data: bool, ) -> WorkSheetResult<()>

fn write_row<L: Location, T: CellDisplay + CellValue>( &mut self, loc: L, data: &[T], ) -> WorkSheetResult<()>

fn write_row_cells<L: Location, T: CellDisplay + CellValue + Clone>( &mut self, loc: L, cells: &[Cell<T>], ) -> WorkSheetResult<()>

fn write_column<L: Location, T: CellDisplay + CellValue>( &mut self, loc: L, data: &[T], ) -> WorkSheetResult<()>

fn write_column_cells<L: Location, T: CellDisplay + CellValue + Clone>( &mut self, loc: L, cells: &[Cell<T>], ) -> WorkSheetResult<()>

fn write_url<L: Location>(&mut self, loc: L, url: &str) -> WorkSheetResult<()>

fn write_url_text<L: Location, T: CellDisplay + CellValue>( &mut self, loc: L, url: &str, data: &str, ) -> WorkSheetResult<()>

fn merge_range<L: LocationRange, T: CellDisplay + CellValue>( &mut self, loc: L, data: T, ) -> WorkSheetResult<()>

fn write_formula<L: Location>( &mut self, loc: L, data: &str, ) -> WorkSheetResult<()>

fn write_old_formula<L: Location>( &mut self, loc: L, data: &str, ) -> WorkSheetResult<()>

fn write_array_formula<L: Location>( &mut self, loc: L, data: &str, ) -> WorkSheetResult<()>

fn write_dynamic_array_formula<L: Location>( &mut self, loc: L, data: &str, ) -> WorkSheetResult<()>

fn write_with_format<L: Location, T: Default + Clone + CellDisplay + CellValue>( &mut self, loc: L, data: T, format: &Format, ) -> WorkSheetResult<()>

fn write_string_with_format<L: Location>( &mut self, loc: L, data: String, format: &Format, ) -> WorkSheetResult<()>

fn write_number_with_format<L: Location>( &mut self, loc: L, data: i32, format: &Format, ) -> WorkSheetResult<()>

fn write_double_with_format<L: Location>( &mut self, loc: L, data: f64, format: &Format, ) -> WorkSheetResult<()>

fn write_boolean_with_format<L: Location>( &mut self, loc: L, data: bool, format: &Format, ) -> WorkSheetResult<()>

fn write_row_with_format<L: Location, T: CellDisplay + CellValue>( &mut self, loc: L, data: Iter<'_, T>, format: &Format, ) -> WorkSheetResult<()>

fn write_column_with_format<L: Location, T: CellDisplay + CellValue>( &mut self, loc: L, data: Iter<'_, T>, format: &Format, ) -> WorkSheetResult<()>

fn write_url_with_format<L: Location>( &mut self, loc: L, url: &str, format: &Format, ) -> WorkSheetResult<()>

fn write_url_text_with_format<L: Location>( &mut self, loc: L, url: &str, data: &str, format: &Format, ) -> WorkSheetResult<()>

fn write_formula_with_format<L: Location>( &mut self, loc: L, data: &str, format: &Format, ) -> WorkSheetResult<()>

fn write_array_formula_with_format<L: Location>( &mut self, loc: L, data: &str, format: &Format, ) -> WorkSheetResult<()>

fn write_dynamic_array_formula_with_format<L: LocationRange>( &mut self, loc_range: L, data: &str, format: &Format, ) -> WorkSheetResult<()>

fn merge_range_with_format<L: LocationRange, T: CellDisplay + CellValue>( &mut self, loc: L, data: T, format: &Format, ) -> WorkSheetResult<()>