├── .github ├── FUNDING.yml └── workflows │ └── rust.yml ├── .gitignore ├── CHANGELOG.md ├── Cargo.toml ├── LICENSE ├── README.md ├── USS.code-workspace ├── images ├── chart │ └── chart_title.png ├── sample1.png ├── sample2.png ├── sample3.png ├── sample4.png ├── style │ ├── style_border.png │ ├── style_fill_color.png │ └── style_font_color.png └── title.png ├── src ├── helper.rs ├── helper │ ├── address.rs │ ├── binary.rs │ ├── color.rs │ ├── const_str.rs │ ├── coordinate.rs │ ├── crypt.rs │ ├── date.rs │ ├── formula.rs │ ├── html.rs │ ├── number_format.rs │ ├── number_format │ │ ├── date_formater.rs │ │ ├── fraction_formater.rs │ │ ├── number_formater.rs │ │ └── percentage_formater.rs │ ├── range.rs │ ├── string_helper.rs │ ├── time_zone.rs │ └── utils.rs ├── lib.rs ├── reader.rs ├── reader │ ├── driver.rs │ ├── xlsx.rs │ └── xlsx │ │ ├── chart.rs │ │ ├── comment.rs │ │ ├── content_types.rs │ │ ├── doc_props_app.rs │ │ ├── doc_props_core.rs │ │ ├── doc_props_custom.rs │ │ ├── drawing.rs │ │ ├── pivot_table.rs │ │ ├── rels.rs │ │ ├── shared_strings.rs │ │ ├── styles.rs │ │ ├── table.rs │ │ ├── theme.rs │ │ ├── vba_project_bin.rs │ │ ├── vml_drawing.rs │ │ ├── workbook.rs │ │ ├── workbook_rels.rs │ │ └── worksheet.rs ├── structs.rs ├── structs │ ├── address.rs │ ├── alignment.rs │ ├── anchor.rs │ ├── auto_filter.rs │ ├── bold.rs │ ├── boolean_value.rs │ ├── border.rs │ ├── border_properties_type.rs │ ├── border_style_values.rs │ ├── borders.rs │ ├── borders_crate.rs │ ├── break.rs │ ├── byte_value.rs │ ├── cache_field.rs │ ├── cache_fields.rs │ ├── cache_source.rs │ ├── cell.rs │ ├── cell_format.rs │ ├── cell_formats.rs │ ├── cell_formula.rs │ ├── cell_formula_values.rs │ ├── cell_raw_value.rs │ ├── cell_style.rs │ ├── cell_style_formats.rs │ ├── cell_styles.rs │ ├── cell_value.rs │ ├── cells.rs │ ├── chart.rs │ ├── chart_type.rs │ ├── color.rs │ ├── color_scale.rs │ ├── colors.rs │ ├── column.rs │ ├── column_breaks.rs │ ├── column_fields.rs │ ├── column_items.rs │ ├── column_reference.rs │ ├── columns.rs │ ├── comment.rs │ ├── conditional_format_value_object.rs │ ├── conditional_format_value_object_values.rs │ ├── conditional_format_values.rs │ ├── conditional_formatting.rs │ ├── conditional_formatting_operator_values.rs │ ├── conditional_formatting_rule.rs │ ├── coordinate.rs │ ├── csv_encode_values.rs │ ├── csv_writer_option.rs │ ├── custom_properties.rs │ ├── custom_properties │ │ ├── custom_document_property.rs │ │ ├── custom_document_property_value.rs │ │ └── properties.rs │ ├── data_bar.rs │ ├── data_field.rs │ ├── data_fields.rs │ ├── data_validation.rs │ ├── data_validation_operator_values.rs │ ├── data_validation_values.rs │ ├── data_validations.rs │ ├── defined_name.rs │ ├── diagonal_border.rs │ ├── differential_format.rs │ ├── differential_formats.rs │ ├── double_value.rs │ ├── drawing.rs │ ├── drawing │ │ ├── adjust_value_list.rs │ │ ├── alpha.rs │ │ ├── background_color.rs │ │ ├── background_fill_style_list.rs │ │ ├── bevel.rs │ │ ├── bevel_bottom.rs │ │ ├── bevel_preset_values.rs │ │ ├── bevel_top.rs │ │ ├── blip.rs │ │ ├── blip_fill.rs │ │ ├── body_properties.rs │ │ ├── camera.rs │ │ ├── charts.rs │ │ ├── charts │ │ │ ├── area_3d_chart.rs │ │ │ ├── area_chart.rs │ │ │ ├── area_chart_series.rs │ │ │ ├── area_chart_series_list.rs │ │ │ ├── auto_labeled.rs │ │ │ ├── auto_title_deleted.rs │ │ │ ├── axis_id.rs │ │ │ ├── axis_position.rs │ │ │ ├── axis_position_values.rs │ │ │ ├── back_wall.rs │ │ │ ├── bar_3d_chart.rs │ │ │ ├── bar_chart.rs │ │ │ ├── bar_direction.rs │ │ │ ├── bar_direction_values.rs │ │ │ ├── base_time_unit.rs │ │ │ ├── bubble_3d.rs │ │ │ ├── bubble_chart.rs │ │ │ ├── bubble_scale.rs │ │ │ ├── bubble_size.rs │ │ │ ├── category_axis.rs │ │ │ ├── category_axis_data.rs │ │ │ ├── chart.rs │ │ │ ├── chart_space.rs │ │ │ ├── chart_text.rs │ │ │ ├── cross_between.rs │ │ │ ├── cross_between_values.rs │ │ │ ├── crosses.rs │ │ │ ├── crosses_values.rs │ │ │ ├── crossing_axis.rs │ │ │ ├── data_labels.rs │ │ │ ├── date1904.rs │ │ │ ├── date_axis.rs │ │ │ ├── delete.rs │ │ │ ├── display_blanks_as.rs │ │ │ ├── display_blanks_as_values.rs │ │ │ ├── doughnut_chart.rs │ │ │ ├── editing_language.rs │ │ │ ├── explosion.rs │ │ │ ├── first_slice_angle.rs │ │ │ ├── floor.rs │ │ │ ├── format_code.rs │ │ │ ├── formula.rs │ │ │ ├── gap_width.rs │ │ │ ├── grouping.rs │ │ │ ├── grouping_values.rs │ │ │ ├── header_footer.rs │ │ │ ├── height.rs │ │ │ ├── height_mode.rs │ │ │ ├── hole_size.rs │ │ │ ├── index.rs │ │ │ ├── invert_if_negative.rs │ │ │ ├── label_alignment.rs │ │ │ ├── label_alignment_values.rs │ │ │ ├── label_offset.rs │ │ │ ├── layout.rs │ │ │ ├── layout_mode_values.rs │ │ │ ├── layout_target.rs │ │ │ ├── layout_target_values.rs │ │ │ ├── left.rs │ │ │ ├── left_mode.rs │ │ │ ├── legend.rs │ │ │ ├── legend_position.rs │ │ │ ├── legend_position_values.rs │ │ │ ├── line_3d_chart.rs │ │ │ ├── line_chart.rs │ │ │ ├── major_gridlines.rs │ │ │ ├── major_tick_mark.rs │ │ │ ├── manual_layout.rs │ │ │ ├── marker.rs │ │ │ ├── marker_style_values.rs │ │ │ ├── minor_tick_mark.rs │ │ │ ├── no_multi_level_labels.rs │ │ │ ├── number_reference.rs │ │ │ ├── numbering_cache.rs │ │ │ ├── numbering_format.rs │ │ │ ├── numeric_value.rs │ │ │ ├── of_pie_chart.rs │ │ │ ├── of_pie_type.rs │ │ │ ├── of_pie_values.rs │ │ │ ├── order.rs │ │ │ ├── orientation.rs │ │ │ ├── orientation_values.rs │ │ │ ├── overlap.rs │ │ │ ├── overlay.rs │ │ │ ├── page_margins.rs │ │ │ ├── page_setup.rs │ │ │ ├── perspective.rs │ │ │ ├── pie_3d_chart.rs │ │ │ ├── pie_chart.rs │ │ │ ├── plot_area.rs │ │ │ ├── plot_visible_only.rs │ │ │ ├── print_settings.rs │ │ │ ├── radar_chart.rs │ │ │ ├── radar_style.rs │ │ │ ├── radar_style_values.rs │ │ │ ├── rich_text.rs │ │ │ ├── right_angle_axes.rs │ │ │ ├── rotate_x.rs │ │ │ ├── rotate_y.rs │ │ │ ├── rounded_corners.rs │ │ │ ├── scaling.rs │ │ │ ├── scatter_chart.rs │ │ │ ├── scatter_style.rs │ │ │ ├── scatter_style_values.rs │ │ │ ├── second_pie_size.rs │ │ │ ├── series_axis.rs │ │ │ ├── series_lines.rs │ │ │ ├── series_text.rs │ │ │ ├── shape.rs │ │ │ ├── shape_properties.rs │ │ │ ├── shape_values.rs │ │ │ ├── show_bubble_size.rs │ │ │ ├── show_category_name.rs │ │ │ ├── show_data_labels_over_maximum.rs │ │ │ ├── show_leader_lines.rs │ │ │ ├── show_legend_key.rs │ │ │ ├── show_marker.rs │ │ │ ├── show_negative_bubbles.rs │ │ │ ├── show_percent.rs │ │ │ ├── show_series_name.rs │ │ │ ├── show_value.rs │ │ │ ├── side_wall.rs │ │ │ ├── size.rs │ │ │ ├── smooth.rs │ │ │ ├── string_cache.rs │ │ │ ├── string_literal.rs │ │ │ ├── string_point.rs │ │ │ ├── string_reference.rs │ │ │ ├── style.rs │ │ │ ├── symbol.rs │ │ │ ├── text_properties.rs │ │ │ ├── thickness.rs │ │ │ ├── tick_label_position.rs │ │ │ ├── tick_label_position_values.rs │ │ │ ├── tick_mark_values.rs │ │ │ ├── time_unit_values.rs │ │ │ ├── title.rs │ │ │ ├── top.rs │ │ │ ├── top_mode.rs │ │ │ ├── value_axis.rs │ │ │ ├── values.rs │ │ │ ├── vary_colors.rs │ │ │ ├── view_3d.rs │ │ │ ├── width.rs │ │ │ ├── width_mode.rs │ │ │ ├── x_values.rs │ │ │ └── y_values.rs │ │ ├── color2_type.rs │ │ ├── color_scheme.rs │ │ ├── effect_list.rs │ │ ├── effect_style.rs │ │ ├── effect_style_list.rs │ │ ├── end_connection.rs │ │ ├── extension_list.rs │ │ ├── extents.rs │ │ ├── fill_rectangle.rs │ │ ├── fill_style_list.rs │ │ ├── font_collection_type.rs │ │ ├── font_scheme.rs │ │ ├── foreground_color.rs │ │ ├── format_scheme.rs │ │ ├── glow.rs │ │ ├── gradient_fill.rs │ │ ├── gradient_stop.rs │ │ ├── gradient_stop_list.rs │ │ ├── graphic.rs │ │ ├── graphic_data.rs │ │ ├── group_shape_locks.rs │ │ ├── light_rig.rs │ │ ├── light_rig_direction_values.rs │ │ ├── light_rig_values.rs │ │ ├── line_spacing.rs │ │ ├── line_style_list.rs │ │ ├── linear_gradient_fill.rs │ │ ├── list_style.rs │ │ ├── miter.rs │ │ ├── no_fill.rs │ │ ├── offset.rs │ │ ├── outer_shadow.rs │ │ ├── outline.rs │ │ ├── paragraph.rs │ │ ├── paragraph_properties.rs │ │ ├── pattern_fill.rs │ │ ├── pen_alignment_values.rs │ │ ├── percentage_type.rs │ │ ├── picture_locks.rs │ │ ├── pictures.rs │ │ ├── point_2d_type.rs │ │ ├── positive_fixed_percentage_type.rs │ │ ├── positive_size_2d_type.rs │ │ ├── preset_camera_values.rs │ │ ├── preset_color.rs │ │ ├── preset_dash.rs │ │ ├── preset_geometry.rs │ │ ├── preset_line_dash_values.rs │ │ ├── preset_material_type_values.rs │ │ ├── rgb_color_model_hex.rs │ │ ├── rotation.rs │ │ ├── round.rs │ │ ├── run.rs │ │ ├── run_properties.rs │ │ ├── scene_3d_type.rs │ │ ├── scheme_color.rs │ │ ├── scheme_color_values.rs │ │ ├── shape_3d_type.rs │ │ ├── shape_auto_fit.rs │ │ ├── shape_guide.rs │ │ ├── soft_edge.rs │ │ ├── solid_fill.rs │ │ ├── source_rectangle.rs │ │ ├── space_after.rs │ │ ├── space_before.rs │ │ ├── spacing_percent.rs │ │ ├── spreadsheet.rs │ │ ├── spreadsheet │ │ │ ├── blip_fill.rs │ │ │ ├── connection_shape.rs │ │ │ ├── edit_as_values.rs │ │ │ ├── extent.rs │ │ │ ├── from_marker.rs │ │ │ ├── graphic_frame.rs │ │ │ ├── group_shape.rs │ │ │ ├── group_shape_properties.rs │ │ │ ├── marker_type.rs │ │ │ ├── non_visual_connection_shape_properties.rs │ │ │ ├── non_visual_connector_shape_drawing_properties.rs │ │ │ ├── non_visual_drawing_properties.rs │ │ │ ├── non_visual_graphic_frame_drawing_properties.rs │ │ │ ├── non_visual_graphic_frame_properties.rs │ │ │ ├── non_visual_group_shape_drawing_properties.rs │ │ │ ├── non_visual_group_shape_properties.rs │ │ │ ├── non_visual_picture_drawing_properties.rs │ │ │ ├── non_visual_picture_properties.rs │ │ │ ├── non_visual_shape_properties.rs │ │ │ ├── one_cell_anchor.rs │ │ │ ├── picture.rs │ │ │ ├── shape.rs │ │ │ ├── shape_properties.rs │ │ │ ├── shape_style.rs │ │ │ ├── text_body.rs │ │ │ ├── to_marker.rs │ │ │ ├── transform.rs │ │ │ ├── two_cell_anchor.rs │ │ │ └── worksheet_drawing.rs │ │ ├── start_connection.rs │ │ ├── stretch.rs │ │ ├── style_matrix_reference_type.rs │ │ ├── supplemental_font.rs │ │ ├── system_color.rs │ │ ├── system_color_values.rs │ │ ├── tail_end.rs │ │ ├── text_alignment_type_values.rs │ │ ├── text_caps_values.rs │ │ ├── text_font_alignment_values.rs │ │ ├── text_font_type.rs │ │ ├── text_paragraph_properties_type.rs │ │ ├── text_wrapping_values.rs │ │ ├── theme.rs │ │ ├── theme_elements.rs │ │ ├── tile_flip_values.rs │ │ ├── tile_rectangle.rs │ │ └── transform2d.rs │ ├── embedded_object_properties.rs │ ├── enum_trait.rs │ ├── enum_value.rs │ ├── error.rs │ ├── field.rs │ ├── fill.rs │ ├── fills.rs │ ├── font.rs │ ├── font_char_set.rs │ ├── font_family_numbering.rs │ ├── font_name.rs │ ├── font_scheme.rs │ ├── font_scheme_values.rs │ ├── font_size.rs │ ├── fonts.rs │ ├── formula.rs │ ├── from_marker.rs │ ├── gradient_fill.rs │ ├── gradient_stop.rs │ ├── header_footer.rs │ ├── horizontal_alignment_values.rs │ ├── hyperlink.rs │ ├── icon_set.rs │ ├── image.rs │ ├── int16_value.rs │ ├── int32_value.rs │ ├── int64_value.rs │ ├── italic.rs │ ├── item_values.rs │ ├── location.rs │ ├── media_object.rs │ ├── member_property_index.rs │ ├── merge_cells.rs │ ├── mru_colors.rs │ ├── numbering_format.rs │ ├── numbering_formats.rs │ ├── object_anchor.rs │ ├── odd_footer.rs │ ├── odd_header.rs │ ├── office.rs │ ├── office │ │ ├── excel.rs │ │ └── excel │ │ │ ├── formula.rs │ │ │ └── reference_sequence.rs │ ├── office2010.rs │ ├── office2010 │ │ ├── drawing.rs │ │ ├── drawing │ │ │ ├── charts.rs │ │ │ └── charts │ │ │ │ └── style.rs │ │ ├── excel.rs │ │ └── excel │ │ │ ├── data_validation.rs │ │ │ ├── data_validation_forumla1.rs │ │ │ ├── data_validation_forumla2.rs │ │ │ └── data_validations.rs │ ├── ole_object.rs │ ├── ole_objects.rs │ ├── orientation_values.rs │ ├── page_margins.rs │ ├── page_setup.rs │ ├── pane.rs │ ├── pane_state_values.rs │ ├── pane_values.rs │ ├── pattern_fill.rs │ ├── pattern_values.rs │ ├── phonetic_run.rs │ ├── pivot_cache_definition.rs │ ├── pivot_field.rs │ ├── pivot_fields.rs │ ├── pivot_table.rs │ ├── pivot_table_definition.rs │ ├── pivot_table_style.rs │ ├── print_options.rs │ ├── properties.rs │ ├── protection.rs │ ├── range.rs │ ├── raw.rs │ ├── raw │ │ ├── raw_file.rs │ │ ├── raw_relationship.rs │ │ ├── raw_relationships.rs │ │ └── raw_worksheet.rs │ ├── rich_text.rs │ ├── row.rs │ ├── row_breaks.rs │ ├── row_item.rs │ ├── row_items.rs │ ├── row_reference.rs │ ├── rows.rs │ ├── s_byte_value.rs │ ├── selection.rs │ ├── sequence_of_references.rs │ ├── shared_items.rs │ ├── shared_string_item.rs │ ├── shared_string_table.rs │ ├── sheet_format_properties.rs │ ├── sheet_protection.rs │ ├── sheet_state_values.rs │ ├── sheet_view.rs │ ├── sheet_view_values.rs │ ├── sheet_views.rs │ ├── source_values.rs │ ├── spreadsheet.rs │ ├── strike.rs │ ├── string_value.rs │ ├── style.rs │ ├── stylesheet.rs │ ├── tab_color.rs │ ├── table.rs │ ├── text.rs │ ├── text_element.rs │ ├── time_period_values.rs │ ├── to_marker.rs │ ├── totals_row_function_values.rs │ ├── true_false_blank_value.rs │ ├── true_false_value.rs │ ├── u_int16_value.rs │ ├── u_int32_value.rs │ ├── underline.rs │ ├── underline_values.rs │ ├── vertical_alignment_run_values.rs │ ├── vertical_alignment_values.rs │ ├── vertical_text_alignment.rs │ ├── vml.rs │ ├── vml │ │ ├── fill.rs │ │ ├── image_data.rs │ │ ├── office.rs │ │ ├── office │ │ │ ├── connect_values.rs │ │ │ └── inset_margin_values.rs │ │ ├── path.rs │ │ ├── shadow.rs │ │ ├── shape.rs │ │ ├── spreadsheet.rs │ │ ├── spreadsheet │ │ │ ├── anchor.rs │ │ │ ├── auto_fill.rs │ │ │ ├── auto_size_picture.rs │ │ │ ├── client_data.rs │ │ │ ├── clipboard_format.rs │ │ │ ├── clipboard_format_values.rs │ │ │ ├── comment_column_target.rs │ │ │ ├── comment_row_target.rs │ │ │ ├── move_with_cells.rs │ │ │ ├── object_values.rs │ │ │ ├── resize_with_cells.rs │ │ │ └── visible.rs │ │ ├── stroke.rs │ │ └── text_box.rs │ ├── workbook_protection.rs │ ├── workbook_view.rs │ ├── worksheet.rs │ ├── worksheet_source.rs │ └── writer_manager.rs ├── traits.rs ├── traits │ ├── adjustment_coordinate.rs │ ├── adjustment_coordinate_with_2sheet.rs │ ├── adjustment_coordinate_with_sheet.rs │ └── adjustment_value.rs ├── writer.rs └── writer │ ├── csv.rs │ ├── driver.rs │ ├── xlsx.rs │ └── xlsx │ ├── chart.rs │ ├── comment.rs │ ├── content_types.rs │ ├── doc_props_app.rs │ ├── doc_props_core.rs │ ├── doc_props_custom.rs │ ├── drawing.rs │ ├── drawing_rels.rs │ ├── embeddings.rs │ ├── media.rs │ ├── printer_settings.rs │ ├── rels.rs │ ├── shared_strings.rs │ ├── styles.rs │ ├── table.rs │ ├── theme.rs │ ├── vba_project_bin.rs │ ├── vml_drawing.rs │ ├── vml_drawing_rels.rs │ ├── workbook.rs │ ├── workbook_rels.rs │ ├── worksheet.rs │ └── worksheet_rels.rs └── tests ├── integration_test.rs ├── result_files └── .gitignore └── test_files ├── aaa.xlsm ├── aaa.xlsx ├── aaa_2.xlsx ├── aaa_empty.xlsx ├── aaa_insertCell.xlsx ├── aaa_large.xlsx ├── aaa_large_string.xlsx ├── aaa_move_range.xlsx ├── aaa_theme.xlsx ├── book_lock.xlsx ├── google.xlsx ├── issue_147.xlsx ├── issue_162.xlsx ├── issue_178.xlsx ├── issue_178_2.xlsx ├── issue_181.xlsx ├── issue_181_2.xlsx ├── issue_184.xlsx ├── issue_184_2.xlsx ├── issue_185.xlsx ├── issue_187.xlsx ├── issue_188.xlsx ├── issue_188_2.xlsx ├── issue_188_3.xlsx ├── issue_188_4.xlsx ├── issue_189.xlsx ├── issue_190.xlsx ├── issue_194.xlsx ├── issue_194_2.xlsx ├── issue_200.xlsx ├── issue_201.xlsx ├── issue_206.xlsx ├── issue_208.xlsx ├── issue_210.xlsx ├── issue_215.xlsx ├── issue_216.xlsx ├── issue_217.xlsx ├── issue_219.xlsx ├── issue_220.xlsx ├── issue_222.xlsx ├── issue_225.xlsx ├── issue_232.xlsx ├── issue_233.xlsx ├── issue_244.xlsx ├── issue_246.xlsx ├── issue_268.xlsx ├── issue_281.xlsx ├── libre.xlsm ├── libre2.xlsx ├── openpyxl.xlsx ├── pr_204.xlsx ├── red_indexed_color.xlsx ├── sheet_lock.xlsx ├── table.xlsx ├── wb_with_shared_strings.xlsx └── wps_comment.xlsx /.github/FUNDING.yml: -------------------------------------------------------------------------------- 1 | # These are supported funding model platforms 2 | 3 | github: MathNya # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2] 4 | patreon: # Replace with a single Patreon username 5 | open_collective: # Replace with a single Open Collective username 6 | ko_fi: # Replace with a single Ko-fi username 7 | tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel 8 | community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry 9 | liberapay: # Replace with a single Liberapay username 10 | issuehunt: # Replace with a single IssueHunt username 11 | otechie: # Replace with a single Otechie username 12 | lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry 13 | custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2'] 14 | -------------------------------------------------------------------------------- /.github/workflows/rust.yml: -------------------------------------------------------------------------------- 1 | name: umya-spreadsheet 2 | 3 | on: 4 | push: 5 | branches: ["*"] 6 | pull_request: 7 | branches: ["*"] 8 | 9 | env: 10 | CARGO_TERM_COLOR: always 11 | 12 | jobs: 13 | build: 14 | runs-on: ubuntu-latest 15 | 16 | steps: 17 | - uses: actions/checkout@v4 18 | 19 | - name: Install Rust 20 | run: rustup component add rustfmt clippy 21 | 22 | - name: Run Lint & Tests 23 | run: | 24 | cargo clippy -- -D warnings 25 | cargo fmt --all -- --check 26 | cargo test 27 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Generated by Cargo 2 | # will have compiled files and executables 3 | /target/ 4 | 5 | # Remove Cargo.lock from gitignore if creating an executable, leave it for libraries 6 | # More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html 7 | Cargo.lock 8 | 9 | # These are backup files generated by rustfmt 10 | **/*.rs.bk 11 | 12 | .vscode/ 13 | .DS_Store 14 | -------------------------------------------------------------------------------- /Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "umya-spreadsheet" 3 | version = "2.3.0" 4 | authors = ["MathNya "] 5 | repository = "https://github.com/MathNya/umya-spreadsheet" 6 | keywords = ["excel", "spreadsheet", "xlsx", "reader", "writer"] 7 | license = "MIT" 8 | readme = "README.md" 9 | description = "umya-spreadsheet is a library written in pure Rust to read and write xlsx file." 10 | edition = "2021" 11 | 12 | # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html 13 | 14 | [dependencies] 15 | aes = "0.8.4" 16 | ahash = "0.8.11" 17 | base64 = "0.22.1" 18 | byteorder = "1.5" 19 | cbc = "0.1.2" 20 | cfb = "0.10.0" 21 | chrono = { version = "0.4.38", default-features = false, features = ["clock"] } 22 | encoding_rs = "0.8.35" 23 | fancy-regex = "0.14.0" 24 | getrandom = { version = "0.2.15" } 25 | hmac = "0.12.1" 26 | html_parser = "0.7.0" 27 | imagesize = "0.14" 28 | lazy_static = "1.5.0" 29 | md-5 = "0.10.6" 30 | regex = "1.11.1" 31 | sha2 = "0.10.8" 32 | thin-vec = "0.2.13" 33 | thousands = "0.2.0" 34 | quick-xml = { version = "0.37.1", features = ["serialize"] } 35 | zip = { version = "2.2.1", default-features = false, features = ["deflate"] } 36 | 37 | [lib] 38 | doctest = false 39 | 40 | [features] 41 | js = ["getrandom/js"] 42 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2020 MathNya 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /USS.code-workspace: -------------------------------------------------------------------------------- 1 | { 2 | "folders": [ 3 | { 4 | "path": "../umya-spreadsheet" 5 | }, 6 | ], 7 | "settings": { 8 | "debug.allowBreakpointsEverywhere": true 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /images/chart/chart_title.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/images/chart/chart_title.png -------------------------------------------------------------------------------- /images/sample1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/images/sample1.png -------------------------------------------------------------------------------- /images/sample2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/images/sample2.png -------------------------------------------------------------------------------- /images/sample3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/images/sample3.png -------------------------------------------------------------------------------- /images/sample4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/images/sample4.png -------------------------------------------------------------------------------- /images/style/style_border.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/images/style/style_border.png -------------------------------------------------------------------------------- /images/style/style_fill_color.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/images/style/style_fill_color.png -------------------------------------------------------------------------------- /images/style/style_font_color.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/images/style/style_font_color.png -------------------------------------------------------------------------------- /images/title.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/images/title.png -------------------------------------------------------------------------------- /src/helper.rs: -------------------------------------------------------------------------------- 1 | pub mod address; 2 | pub mod binary; 3 | pub mod color; 4 | pub mod const_str; 5 | pub mod coordinate; 6 | pub mod crypt; 7 | pub mod date; 8 | pub mod formula; 9 | pub mod html; 10 | pub mod number_format; 11 | pub mod range; 12 | pub mod string_helper; 13 | pub mod time_zone; 14 | pub mod utils; 15 | -------------------------------------------------------------------------------- /src/helper/binary.rs: -------------------------------------------------------------------------------- 1 | use crate::structs::MediaObject; 2 | use base64::{engine::general_purpose::STANDARD, Engine as _}; 3 | use std::fs; 4 | use std::fs::File; 5 | use std::io::BufReader; 6 | use std::io::Cursor; 7 | use std::io::Read; 8 | 9 | #[inline] 10 | pub fn get_binary_data(path: &str) -> Vec { 11 | let path = std::path::Path::new(path); 12 | let mut buf = Vec::new(); 13 | 14 | let file = File::open(path).unwrap(); 15 | BufReader::new(file).read_to_end(&mut buf).unwrap(); 16 | return buf; 17 | } 18 | 19 | #[inline] 20 | pub fn make_media_object(path: &str) -> MediaObject { 21 | let name = path.split("/").last().unwrap(); 22 | let mut obj = MediaObject::default(); 23 | obj.set_image_data(get_binary_data(path)); 24 | obj.set_image_name(name); 25 | obj.set_image_title(name.split(".").next().unwrap_or("")); 26 | obj 27 | } 28 | -------------------------------------------------------------------------------- /src/helper/number_format/percentage_formater.rs: -------------------------------------------------------------------------------- 1 | use std::borrow::Cow; 2 | 3 | pub(crate) fn format_as_percentage<'input>(value: &f64, format: &'input str) -> Cow<'input, str> { 4 | let mut value = value.to_string(); 5 | let mut format = Cow::Borrowed(format); 6 | format = Cow::Owned(format.replace('%', "")); 7 | let blocks: Vec<&str> = format.split('.').collect(); 8 | let len = match blocks.get(1) { 9 | Some(v) => v.len(), 10 | None => 0, 11 | }; 12 | value = format!( 13 | "{:0width$.len$}%", 14 | (100f64 * &value.parse::().unwrap()).round(), 15 | width = 1, 16 | len = len 17 | ); 18 | Cow::Owned(value) 19 | } 20 | -------------------------------------------------------------------------------- /src/helper/string_helper.rs: -------------------------------------------------------------------------------- 1 | #[inline] 2 | pub(crate) fn _get_currency_code() -> String { 3 | String::new() 4 | } 5 | 6 | #[inline] 7 | pub(crate) fn _get_decimal_separator() -> String { 8 | String::from(".") 9 | } 10 | 11 | #[inline] 12 | pub(crate) fn _get_thousands_separator() -> String { 13 | String::from(",") 14 | } 15 | -------------------------------------------------------------------------------- /src/helper/time_zone.rs: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /src/helper/utils.rs: -------------------------------------------------------------------------------- 1 | #[macro_export] 2 | macro_rules! from_err { 3 | ($from:ty, $to:tt, $var:tt) => { 4 | impl From<$from> for $to { 5 | #[inline] 6 | fn from(e: $from) -> $to { 7 | $to::$var(e) 8 | } 9 | } 10 | }; 11 | } 12 | -------------------------------------------------------------------------------- /src/reader.rs: -------------------------------------------------------------------------------- 1 | //! file reader library. 2 | 3 | pub(crate) mod driver; 4 | pub mod xlsx; 5 | -------------------------------------------------------------------------------- /src/reader/xlsx/chart.rs: -------------------------------------------------------------------------------- 1 | use super::XlsxError; 2 | use crate::structs::drawing::charts::ChartSpace; 3 | use crate::structs::raw::RawFile; 4 | use crate::xml_read_loop; 5 | use quick_xml::events::Event; 6 | use quick_xml::Reader; 7 | use std::result; 8 | 9 | pub(crate) fn read( 10 | raw_file: &RawFile, 11 | chart_space: &mut ChartSpace, 12 | ) -> result::Result<(), XlsxError> { 13 | let data = std::io::Cursor::new(raw_file.get_file_data()); 14 | let mut reader = Reader::from_reader(data); 15 | 16 | reader.config_mut().trim_text(true); 17 | 18 | xml_read_loop!( 19 | reader, 20 | Event::Start(ref e) => { 21 | if e.name().into_inner() == b"c:chartSpace" { 22 | chart_space.set_attributes(&mut reader, e); 23 | } 24 | }, 25 | Event::Eof => break, 26 | ); 27 | 28 | Ok(()) 29 | } 30 | -------------------------------------------------------------------------------- /src/reader/xlsx/content_types.rs: -------------------------------------------------------------------------------- 1 | use super::driver::*; 2 | use super::XlsxError; 3 | use crate::helper::const_str::*; 4 | use crate::structs::Spreadsheet; 5 | use quick_xml::events::Event; 6 | use quick_xml::Reader; 7 | use std::{io, result}; 8 | 9 | pub(crate) fn read( 10 | arv: &mut zip::ZipArchive, 11 | spreadsheet: &mut Spreadsheet, 12 | ) -> result::Result<(), XlsxError> { 13 | let r = io::BufReader::new(arv.by_name(CONTENT_TYPES)?); 14 | let mut reader = Reader::from_reader(r); 15 | reader.config_mut().trim_text(true); 16 | let mut list: Vec<(String, String)> = Vec::new(); 17 | 18 | xml_read_loop!( 19 | reader, 20 | Event::Empty(ref e) => { 21 | if e.name().into_inner() == b"Override" { 22 | let part_name = get_attribute(e, b"PartName").unwrap(); 23 | let content_type = get_attribute(e, b"ContentType").unwrap(); 24 | list.push((part_name, content_type)); 25 | } 26 | }, 27 | Event::Eof => break, 28 | ); 29 | 30 | spreadsheet.set_backup_context_types(list); 31 | Ok(()) 32 | } 33 | -------------------------------------------------------------------------------- /src/reader/xlsx/rels.rs: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /src/reader/xlsx/shared_strings.rs: -------------------------------------------------------------------------------- 1 | use crate::xml_read_loop; 2 | 3 | use super::XlsxError; 4 | use crate::helper::const_str::*; 5 | use crate::structs::SharedStringTable; 6 | use crate::structs::Spreadsheet; 7 | use quick_xml::events::Event; 8 | use quick_xml::Reader; 9 | use std::{io, result}; 10 | 11 | pub(crate) fn read( 12 | arv: &mut zip::ZipArchive, 13 | spreadsheet: &mut Spreadsheet, 14 | ) -> result::Result<(), XlsxError> { 15 | let r = io::BufReader::new(match arv.by_name(PKG_SHARED_STRINGS) { 16 | Ok(v) => v, 17 | Err(zip::result::ZipError::FileNotFound) => { 18 | return Ok(()); 19 | } 20 | Err(e) => { 21 | return Err(e.into()); 22 | } 23 | }); 24 | let mut reader = Reader::from_reader(r); 25 | reader.config_mut().trim_text(false); 26 | 27 | xml_read_loop!( 28 | reader, 29 | Event::Start(ref e) => { 30 | if e.name().into_inner() == b"sst" { 31 | let mut obj = SharedStringTable::default(); 32 | obj.set_attributes(&mut reader, e); 33 | spreadsheet.set_shared_string_table(obj); 34 | } 35 | }, 36 | Event::Eof => break, 37 | ); 38 | 39 | Ok(()) 40 | } 41 | -------------------------------------------------------------------------------- /src/reader/xlsx/styles.rs: -------------------------------------------------------------------------------- 1 | use crate::xml_read_loop; 2 | 3 | use super::XlsxError; 4 | use crate::helper::const_str::*; 5 | use crate::structs::Spreadsheet; 6 | use crate::structs::Stylesheet; 7 | use quick_xml::events::Event; 8 | use quick_xml::Reader; 9 | use std::{io, result}; 10 | 11 | pub fn read( 12 | arv: &mut zip::ZipArchive, 13 | spreadsheet: &mut Spreadsheet, 14 | ) -> result::Result<(), XlsxError> { 15 | let r = io::BufReader::new(arv.by_name(PKG_STYLES)?); 16 | let mut reader = Reader::from_reader(r); 17 | reader.config_mut().trim_text(true); 18 | 19 | let theme = spreadsheet.get_theme().clone(); 20 | 21 | xml_read_loop!( 22 | reader, 23 | Event::Start(ref e) => { 24 | if e.name().into_inner() == b"styleSheet" { 25 | let mut obj = Stylesheet::default(); 26 | obj.set_attributes(&mut reader, e); 27 | obj.make_style(); 28 | spreadsheet.set_stylesheet(obj); 29 | } 30 | }, 31 | Event::Eof => break 32 | ); 33 | 34 | Ok(()) 35 | } 36 | -------------------------------------------------------------------------------- /src/reader/xlsx/theme.rs: -------------------------------------------------------------------------------- 1 | use super::XlsxError; 2 | use crate::structs::drawing::Theme; 3 | use crate::xml_read_loop; 4 | use quick_xml::events::Event; 5 | use quick_xml::Reader; 6 | use std::{io, result}; 7 | 8 | pub fn read( 9 | arv: &mut zip::ZipArchive, 10 | target: &str, 11 | ) -> result::Result { 12 | let r = io::BufReader::new(arv.by_name(&format!("xl/{}", target))?); 13 | let mut reader = Reader::from_reader(r); 14 | reader.config_mut().trim_text(true); 15 | 16 | let mut theme: Theme = Theme::default(); 17 | 18 | xml_read_loop!( 19 | reader, 20 | Event::Start(ref e) => { 21 | if e.name().into_inner() == b"a:theme" { 22 | theme.set_attributes(&mut reader, e); 23 | } 24 | }, 25 | Event::Eof => break, 26 | ); 27 | 28 | Ok(theme) 29 | } 30 | -------------------------------------------------------------------------------- /src/reader/xlsx/vba_project_bin.rs: -------------------------------------------------------------------------------- 1 | use super::XlsxError; 2 | use std::io::Read; 3 | use std::{io, result}; 4 | 5 | use crate::helper::const_str::*; 6 | use crate::structs::Spreadsheet; 7 | 8 | pub(crate) fn read( 9 | arv: &mut zip::ZipArchive, 10 | spreadsheet: &mut Spreadsheet, 11 | ) -> result::Result<(), XlsxError> { 12 | let mut r = io::BufReader::new(match arv.by_name(PKG_VBA_PROJECT) { 13 | Ok(v) => v, 14 | Err(zip::result::ZipError::FileNotFound) => { 15 | return Ok(()); 16 | } 17 | Err(e) => { 18 | return Err(e.into()); 19 | } 20 | }); 21 | let mut buf = Vec::new(); 22 | r.read_to_end(&mut buf)?; 23 | 24 | spreadsheet.set_macros_code(buf); 25 | 26 | Ok(()) 27 | } 28 | -------------------------------------------------------------------------------- /src/structs/bold.rs: -------------------------------------------------------------------------------- 1 | // b 2 | use super::BooleanValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug, Eq, Ord, PartialEq, PartialOrd)] 11 | pub struct Bold { 12 | pub(crate) val: BooleanValue, 13 | } 14 | 15 | impl Bold { 16 | #[inline] 17 | pub fn get_val(&self) -> &bool { 18 | self.val.get_value() 19 | } 20 | 21 | #[inline] 22 | pub fn set_val(&mut self, value: bool) -> &mut Self { 23 | self.val.set_value(value); 24 | self 25 | } 26 | 27 | #[inline] 28 | pub(crate) fn set_attributes( 29 | &mut self, 30 | _reader: &mut Reader, 31 | e: &BytesStart, 32 | ) { 33 | self.val.set_value(true); 34 | set_string_from_xml!(self, e, val, "val"); 35 | } 36 | 37 | #[inline] 38 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 39 | // b 40 | if *self.val.get_value() { 41 | write_start_tag(writer, "b", vec![], true); 42 | } 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /src/structs/boolean_value.rs: -------------------------------------------------------------------------------- 1 | #[derive(Clone, Default, Debug, Eq, Ord, PartialEq, PartialOrd)] 2 | pub struct BooleanValue { 3 | value: Option, 4 | } 5 | 6 | impl BooleanValue { 7 | #[inline] 8 | pub(crate) fn get_value(&self) -> &bool { 9 | self.value.as_ref().unwrap_or(&false) 10 | } 11 | 12 | #[inline] 13 | pub(crate) fn get_value_string(&self) -> &str { 14 | match *self.get_value() { 15 | true => "1", 16 | false => "0", 17 | } 18 | } 19 | 20 | #[inline] 21 | pub(crate) fn set_value(&mut self, value: bool) -> &mut Self { 22 | self.value = Some(value); 23 | self 24 | } 25 | 26 | #[inline] 27 | pub(crate) fn set_value_string>(&mut self, value: S) -> &mut Self { 28 | self.set_value(matches!(value.into().as_str(), "true" | "1")) 29 | } 30 | 31 | #[inline] 32 | pub(crate) fn has_value(&self) -> bool { 33 | self.value.is_some() 34 | } 35 | 36 | #[inline] 37 | pub(crate) fn get_hash_string(&self) -> &str { 38 | if self.has_value() { 39 | return self.get_value_string(); 40 | } 41 | "empty!!" 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /src/structs/border_properties_type.rs: -------------------------------------------------------------------------------- 1 | use super::BorderStyleValues; 2 | use super::Color; 3 | 4 | pub trait BorderPropertiesType { 5 | fn get_color(&self) -> &Color; 6 | 7 | fn get_color_mut(&mut self) -> &mut Color; 8 | 9 | fn set_color(&mut self, value: Color) -> &mut Self; 10 | 11 | fn get_style(&self) -> &BorderStyleValues; 12 | 13 | fn set_style(&mut self, value: BorderStyleValues) -> &mut Self; 14 | } 15 | -------------------------------------------------------------------------------- /src/structs/byte_value.rs: -------------------------------------------------------------------------------- 1 | #[derive(Clone, Default, Debug)] 2 | pub struct ByteValue { 3 | value: Option, 4 | } 5 | impl ByteValue { 6 | #[inline] 7 | pub(crate) fn get_value(&self) -> &u8 { 8 | match &self.value { 9 | Some(v) => v, 10 | None => &0, 11 | } 12 | } 13 | 14 | #[inline] 15 | pub(crate) fn get_value_string(&self) -> String { 16 | self.get_value().to_string() 17 | } 18 | 19 | #[inline] 20 | pub(crate) fn set_value(&mut self, value: u8) -> &mut ByteValue { 21 | self.value = Some(value); 22 | self 23 | } 24 | 25 | #[inline] 26 | pub(crate) fn set_value_string>(&mut self, value: S) -> &mut ByteValue { 27 | self.set_value(value.into().parse::().unwrap()) 28 | } 29 | 30 | #[inline] 31 | pub(crate) fn has_value(&self) -> bool { 32 | self.value.is_some() 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /src/structs/cell_formula_values.rs: -------------------------------------------------------------------------------- 1 | use super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Debug, Clone, Eq, Ord, PartialEq, PartialOrd)] 4 | pub enum CellFormulaValues { 5 | Array, 6 | DataTable, 7 | Normal, 8 | Shared, 9 | } 10 | impl Default for CellFormulaValues { 11 | #[inline] 12 | fn default() -> Self { 13 | Self::Normal 14 | } 15 | } 16 | impl EnumTrait for CellFormulaValues { 17 | #[inline] 18 | fn get_value_string(&self) -> &str { 19 | match &self { 20 | Self::Array => "array", 21 | Self::DataTable => "dataTable", 22 | Self::Normal => "normal", 23 | Self::Shared => "shared", 24 | } 25 | } 26 | } 27 | impl FromStr for CellFormulaValues { 28 | type Err = (); 29 | 30 | #[inline] 31 | fn from_str(input: &str) -> Result { 32 | match input { 33 | "array" => Ok(Self::Array), 34 | "dataTable" => Ok(Self::DataTable), 35 | "normal" => Ok(Self::Normal), 36 | "shared" => Ok(Self::Shared), 37 | _ => Err(()), 38 | } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/structs/csv_writer_option.rs: -------------------------------------------------------------------------------- 1 | use super::EnumValue; 2 | use crate::structs::CsvEncodeValues; 3 | 4 | #[derive(Clone, Default, Debug, Eq, Ord, PartialEq, PartialOrd)] 5 | pub struct CsvWriterOption { 6 | pub(crate) csv_encode_values: EnumValue, 7 | pub(crate) wrap_with_char: Box, 8 | pub(crate) do_trim: bool, 9 | } 10 | impl CsvWriterOption { 11 | #[inline] 12 | pub fn get_csv_encode_value(&self) -> &CsvEncodeValues { 13 | self.csv_encode_values.get_value() 14 | } 15 | 16 | #[inline] 17 | pub fn set_csv_encode_value(&mut self, value: CsvEncodeValues) -> &mut Self { 18 | self.csv_encode_values.set_value(value); 19 | self 20 | } 21 | 22 | #[inline] 23 | pub fn get_wrap_with_char(&self) -> &str { 24 | &self.wrap_with_char 25 | } 26 | 27 | #[inline] 28 | pub fn set_wrap_with_char>(&mut self, value: S) -> &mut Self { 29 | self.wrap_with_char = value.into().into_boxed_str(); 30 | self 31 | } 32 | 33 | #[inline] 34 | pub fn get_do_trim(&self) -> &bool { 35 | &self.do_trim 36 | } 37 | 38 | #[inline] 39 | pub fn set_do_trim(&mut self, value: bool) -> &mut Self { 40 | self.do_trim = value; 41 | self 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /src/structs/custom_properties.rs: -------------------------------------------------------------------------------- 1 | mod custom_document_property; 2 | pub use self::custom_document_property::*; 3 | 4 | mod custom_document_property_value; 5 | pub use self::custom_document_property_value::*; 6 | 7 | mod properties; 8 | pub use self::properties::*; 9 | -------------------------------------------------------------------------------- /src/structs/double_value.rs: -------------------------------------------------------------------------------- 1 | #[derive(Clone, Default, Debug, PartialEq, PartialOrd)] 2 | pub struct DoubleValue { 3 | value: Option, 4 | } 5 | impl DoubleValue { 6 | #[inline] 7 | pub(crate) fn get_value(&self) -> &f64 { 8 | match &self.value { 9 | Some(v) => v, 10 | None => &0f64, 11 | } 12 | } 13 | 14 | #[inline] 15 | pub(crate) fn get_value_string(&self) -> String { 16 | self.get_value().to_string() 17 | } 18 | 19 | #[inline] 20 | pub(crate) fn set_value(&mut self, value: f64) -> &mut Self { 21 | self.value = Some(value); 22 | self 23 | } 24 | 25 | #[inline] 26 | pub(crate) fn set_value_string>(&mut self, value: S) -> &mut Self { 27 | self.set_value(value.into().parse::().unwrap_or_default()) 28 | } 29 | 30 | #[inline] 31 | pub(crate) fn has_value(&self) -> bool { 32 | self.value.is_some() 33 | } 34 | 35 | #[inline] 36 | pub(crate) fn get_hash_string(&self) -> String { 37 | if self.has_value() { 38 | return self.get_value_string(); 39 | } 40 | String::from("empty!!") 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/structs/drawing/alpha.rs: -------------------------------------------------------------------------------- 1 | // a:alpha 2 | use crate::reader::driver::*; 3 | use crate::writer::driver::*; 4 | use quick_xml::events::BytesStart; 5 | use quick_xml::Reader; 6 | use quick_xml::Writer; 7 | use std::io::Cursor; 8 | 9 | #[derive(Clone, Default, Debug)] 10 | pub struct Alpha { 11 | val: Box, 12 | } 13 | impl Alpha { 14 | #[inline] 15 | pub fn get_val(&self) -> &str { 16 | &self.val 17 | } 18 | 19 | #[inline] 20 | pub fn set_val>(&mut self, value: S) { 21 | self.val = value.into().into_boxed_str(); 22 | } 23 | 24 | #[inline] 25 | pub(crate) fn set_attributes( 26 | &mut self, 27 | _reader: &mut Reader, 28 | e: &BytesStart, 29 | ) { 30 | self.set_val(get_attribute(e, b"val").unwrap()); 31 | } 32 | 33 | #[inline] 34 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 35 | // a:alpha 36 | write_start_tag(writer, "a:alpha", vec![("val", &self.val)], true); 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /src/structs/drawing/bevel.rs: -------------------------------------------------------------------------------- 1 | // a:bevel 2 | use crate::writer::driver::*; 3 | use quick_xml::events::BytesStart; 4 | use quick_xml::Reader; 5 | use quick_xml::Writer; 6 | use std::io::Cursor; 7 | 8 | #[derive(Clone, Default, Debug)] 9 | pub struct Bevel {} 10 | impl Bevel { 11 | #[inline] 12 | pub(crate) fn set_attributes( 13 | &mut self, 14 | _reader: &mut Reader, 15 | _e: &BytesStart, 16 | ) { 17 | } 18 | 19 | #[inline] 20 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 21 | // a:bevel 22 | write_start_tag(writer, "a:bevel", vec![], true); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/area_chart_series_list.rs: -------------------------------------------------------------------------------- 1 | use super::AreaChartSeries; 2 | use thin_vec::ThinVec; 3 | 4 | #[derive(Clone, Default, Debug)] 5 | pub struct AreaChartSeriesList { 6 | area_chart_series: ThinVec, 7 | } 8 | impl AreaChartSeriesList { 9 | pub fn get_area_chart_series(&self) -> &[AreaChartSeries] { 10 | &self.area_chart_series 11 | } 12 | 13 | pub fn get_area_chart_series_mut(&mut self) -> &mut [AreaChartSeries] { 14 | &mut self.area_chart_series 15 | } 16 | 17 | pub fn set_area_chart_series( 18 | &mut self, 19 | value: impl Into>, 20 | ) -> &mut Self { 21 | self.area_chart_series = value.into(); 22 | self 23 | } 24 | 25 | pub fn add_area_chart_series(&mut self, value: AreaChartSeries) -> &mut Self { 26 | self.area_chart_series.push(value); 27 | self 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/auto_labeled.rs: -------------------------------------------------------------------------------- 1 | // c:auto 2 | use super::super::super::BooleanValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct AutoLabeled { 12 | val: BooleanValue, 13 | } 14 | impl AutoLabeled { 15 | pub fn get_val(&self) -> &bool { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: bool) -> &mut AutoLabeled { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:auto 34 | write_start_tag( 35 | writer, 36 | "c:auto", 37 | vec![("val", self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/auto_title_deleted.rs: -------------------------------------------------------------------------------- 1 | // c:autoTitleDeleted 2 | use super::super::super::BooleanValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct AutoTitleDeleted { 12 | val: BooleanValue, 13 | } 14 | impl AutoTitleDeleted { 15 | pub fn get_val(&self) -> &bool { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: bool) -> &mut AutoTitleDeleted { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:autoTitleDeleted 34 | write_start_tag( 35 | writer, 36 | "c:autoTitleDeleted", 37 | vec![("val", self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/axis_id.rs: -------------------------------------------------------------------------------- 1 | // c:axId 2 | use super::super::super::UInt32Value; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct AxisId { 12 | val: UInt32Value, 13 | } 14 | impl AxisId { 15 | pub fn get_val(&self) -> &u32 { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: u32) -> &mut AxisId { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:axId 34 | write_start_tag( 35 | writer, 36 | "c:axId", 37 | vec![("val", &self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/axis_position.rs: -------------------------------------------------------------------------------- 1 | // c:axPos 2 | use super::super::super::EnumValue; 3 | use super::AxisPositionValues; 4 | use crate::reader::driver::*; 5 | use crate::writer::driver::*; 6 | use quick_xml::events::BytesStart; 7 | use quick_xml::Reader; 8 | use quick_xml::Writer; 9 | use std::io::Cursor; 10 | 11 | #[derive(Clone, Default, Debug)] 12 | pub struct AxisPosition { 13 | val: EnumValue, 14 | } 15 | impl AxisPosition { 16 | pub fn get_val(&self) -> &AxisPositionValues { 17 | self.val.get_value() 18 | } 19 | 20 | pub fn set_val(&mut self, value: AxisPositionValues) -> &mut AxisPosition { 21 | self.val.set_value(value); 22 | self 23 | } 24 | 25 | pub(crate) fn set_attributes( 26 | &mut self, 27 | _reader: &mut Reader, 28 | e: &BytesStart, 29 | ) { 30 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 31 | } 32 | 33 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 34 | // c:axPos 35 | write_start_tag( 36 | writer, 37 | "c:axPos", 38 | vec![("val", self.val.get_value_string())], 39 | true, 40 | ); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/axis_position_values.rs: -------------------------------------------------------------------------------- 1 | use super::super::super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug)] 4 | pub enum AxisPositionValues { 5 | Bottom, 6 | Left, 7 | Right, 8 | Top, 9 | } 10 | impl Default for AxisPositionValues { 11 | fn default() -> Self { 12 | Self::Bottom 13 | } 14 | } 15 | impl EnumTrait for AxisPositionValues { 16 | fn get_value_string(&self) -> &str { 17 | match &self { 18 | Self::Bottom => "b", 19 | Self::Left => "l", 20 | Self::Right => "r", 21 | Self::Top => "t", 22 | } 23 | } 24 | } 25 | impl FromStr for AxisPositionValues { 26 | type Err = (); 27 | fn from_str(input: &str) -> Result { 28 | match input { 29 | "b" => Ok(Self::Bottom), 30 | "l" => Ok(Self::Left), 31 | "r" => Ok(Self::Right), 32 | "t" => Ok(Self::Top), 33 | _ => Err(()), 34 | } 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/bar_direction.rs: -------------------------------------------------------------------------------- 1 | // c:barDir 2 | use super::super::super::EnumValue; 3 | use super::BarDirectionValues; 4 | use crate::reader::driver::*; 5 | use crate::writer::driver::*; 6 | use quick_xml::events::BytesStart; 7 | use quick_xml::Reader; 8 | use quick_xml::Writer; 9 | use std::io::Cursor; 10 | 11 | #[derive(Clone, Default, Debug)] 12 | pub struct BarDirection { 13 | val: EnumValue, 14 | } 15 | impl BarDirection { 16 | pub fn get_val(&self) -> &BarDirectionValues { 17 | self.val.get_value() 18 | } 19 | 20 | pub fn set_val(&mut self, value: BarDirectionValues) -> &mut BarDirection { 21 | self.val.set_value(value); 22 | self 23 | } 24 | 25 | pub(crate) fn set_attributes( 26 | &mut self, 27 | _reader: &mut Reader, 28 | e: &BytesStart, 29 | ) { 30 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 31 | } 32 | 33 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 34 | // c:barDir 35 | write_start_tag( 36 | writer, 37 | "c:barDir", 38 | vec![("val", self.val.get_value_string())], 39 | true, 40 | ); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/bar_direction_values.rs: -------------------------------------------------------------------------------- 1 | use super::super::super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug)] 4 | pub enum BarDirectionValues { 5 | Bar, 6 | Column, 7 | } 8 | impl Default for BarDirectionValues { 9 | fn default() -> Self { 10 | Self::Bar 11 | } 12 | } 13 | impl EnumTrait for BarDirectionValues { 14 | fn get_value_string(&self) -> &str { 15 | match &self { 16 | Self::Bar => "bar", 17 | Self::Column => "col", 18 | } 19 | } 20 | } 21 | impl FromStr for BarDirectionValues { 22 | type Err = (); 23 | fn from_str(input: &str) -> Result { 24 | match input { 25 | "bar" => Ok(Self::Bar), 26 | "col" => Ok(Self::Column), 27 | _ => Err(()), 28 | } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/base_time_unit.rs: -------------------------------------------------------------------------------- 1 | // c:baseTimeUnit 2 | use super::super::super::EnumValue; 3 | use super::TimeUnitValues; 4 | use crate::reader::driver::*; 5 | use crate::writer::driver::*; 6 | use quick_xml::events::BytesStart; 7 | use quick_xml::Reader; 8 | use quick_xml::Writer; 9 | use std::io::Cursor; 10 | 11 | #[derive(Clone, Default, Debug)] 12 | pub struct BaseTimeUnit { 13 | val: EnumValue, 14 | } 15 | impl BaseTimeUnit { 16 | pub fn get_val(&self) -> &TimeUnitValues { 17 | self.val.get_value() 18 | } 19 | 20 | pub fn set_val(&mut self, value: TimeUnitValues) -> &mut Self { 21 | self.val.set_value(value); 22 | self 23 | } 24 | 25 | pub(crate) fn set_attributes( 26 | &mut self, 27 | _reader: &mut Reader, 28 | e: &BytesStart, 29 | ) { 30 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 31 | } 32 | 33 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 34 | // c:baseTimeUnit 35 | write_start_tag( 36 | writer, 37 | "c:baseTimeUnit", 38 | vec![("val", self.val.get_value_string())], 39 | true, 40 | ); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/bubble_3d.rs: -------------------------------------------------------------------------------- 1 | // c:bubble3D 2 | use super::super::super::BooleanValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct Bubble3D { 12 | val: BooleanValue, 13 | } 14 | impl Bubble3D { 15 | pub fn get_val(&self) -> &bool { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: bool) -> &mut Bubble3D { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:bubble3D 34 | write_start_tag( 35 | writer, 36 | "c:bubble3D", 37 | vec![("val", self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/bubble_scale.rs: -------------------------------------------------------------------------------- 1 | // c:bubbleScale 2 | use super::super::super::UInt32Value; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct BubbleScale { 12 | val: UInt32Value, 13 | } 14 | impl BubbleScale { 15 | pub fn get_val(&self) -> &u32 { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: u32) -> &mut BubbleScale { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:bubbleScale 34 | write_start_tag( 35 | writer, 36 | "c:bubbleScale", 37 | vec![("val", &self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/cross_between.rs: -------------------------------------------------------------------------------- 1 | // c:crossBetween 2 | use super::super::super::EnumValue; 3 | use super::CrossBetweenValues; 4 | use crate::reader::driver::*; 5 | use crate::writer::driver::*; 6 | use quick_xml::events::BytesStart; 7 | use quick_xml::Reader; 8 | use quick_xml::Writer; 9 | use std::io::Cursor; 10 | 11 | #[derive(Clone, Default, Debug)] 12 | pub struct CrossBetween { 13 | val: EnumValue, 14 | } 15 | impl CrossBetween { 16 | pub fn get_val(&self) -> &CrossBetweenValues { 17 | self.val.get_value() 18 | } 19 | 20 | pub fn set_val(&mut self, value: CrossBetweenValues) -> &mut CrossBetween { 21 | self.val.set_value(value); 22 | self 23 | } 24 | 25 | pub(crate) fn set_attributes( 26 | &mut self, 27 | _reader: &mut Reader, 28 | e: &BytesStart, 29 | ) { 30 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 31 | } 32 | 33 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 34 | // c:crossBetween 35 | write_start_tag( 36 | writer, 37 | "c:crossBetween", 38 | vec![("val", self.val.get_value_string())], 39 | true, 40 | ); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/cross_between_values.rs: -------------------------------------------------------------------------------- 1 | use super::super::super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug)] 4 | pub enum CrossBetweenValues { 5 | Between, 6 | MidpointCategory, 7 | } 8 | impl Default for CrossBetweenValues { 9 | fn default() -> Self { 10 | Self::Between 11 | } 12 | } 13 | impl EnumTrait for CrossBetweenValues { 14 | fn get_value_string(&self) -> &str { 15 | match &self { 16 | Self::Between => "between", 17 | Self::MidpointCategory => "midCat", 18 | } 19 | } 20 | } 21 | impl FromStr for CrossBetweenValues { 22 | type Err = (); 23 | fn from_str(input: &str) -> Result { 24 | match input { 25 | "between" => Ok(Self::Between), 26 | "midCat" => Ok(Self::MidpointCategory), 27 | _ => Err(()), 28 | } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/crosses.rs: -------------------------------------------------------------------------------- 1 | // c:crosses 2 | use super::super::super::EnumValue; 3 | use super::CrossesValues; 4 | use crate::reader::driver::*; 5 | use crate::writer::driver::*; 6 | use quick_xml::events::BytesStart; 7 | use quick_xml::Reader; 8 | use quick_xml::Writer; 9 | use std::io::Cursor; 10 | 11 | #[derive(Clone, Default, Debug)] 12 | pub struct Crosses { 13 | val: EnumValue, 14 | } 15 | impl Crosses { 16 | pub fn get_val(&self) -> &CrossesValues { 17 | self.val.get_value() 18 | } 19 | 20 | pub fn set_val(&mut self, value: CrossesValues) -> &mut Crosses { 21 | self.val.set_value(value); 22 | self 23 | } 24 | 25 | pub(crate) fn set_attributes( 26 | &mut self, 27 | _reader: &mut Reader, 28 | e: &BytesStart, 29 | ) { 30 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 31 | } 32 | 33 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 34 | // c:crosses 35 | write_start_tag( 36 | writer, 37 | "c:crosses", 38 | vec![("val", self.val.get_value_string())], 39 | true, 40 | ); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/crosses_values.rs: -------------------------------------------------------------------------------- 1 | use super::super::super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug)] 4 | pub enum CrossesValues { 5 | AutoZero, 6 | Maximum, 7 | Minimum, 8 | } 9 | impl Default for CrossesValues { 10 | fn default() -> Self { 11 | Self::AutoZero 12 | } 13 | } 14 | impl EnumTrait for CrossesValues { 15 | fn get_value_string(&self) -> &str { 16 | match &self { 17 | Self::AutoZero => "autoZero", 18 | Self::Maximum => "max", 19 | Self::Minimum => "min", 20 | } 21 | } 22 | } 23 | impl FromStr for CrossesValues { 24 | type Err = (); 25 | fn from_str(input: &str) -> Result { 26 | match input { 27 | "autoZero" => Ok(Self::AutoZero), 28 | "max" => Ok(Self::Maximum), 29 | "min" => Ok(Self::Minimum), 30 | _ => Err(()), 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/crossing_axis.rs: -------------------------------------------------------------------------------- 1 | // c:crossAx 2 | use super::super::super::UInt32Value; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct CrossingAxis { 12 | val: UInt32Value, 13 | } 14 | impl CrossingAxis { 15 | pub fn get_val(&self) -> &u32 { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: u32) -> &mut CrossingAxis { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:crossAx 34 | write_start_tag( 35 | writer, 36 | "c:crossAx", 37 | vec![("val", &self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/date1904.rs: -------------------------------------------------------------------------------- 1 | // c:h 2 | use super::super::super::BooleanValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct Date1904 { 12 | val: BooleanValue, 13 | } 14 | impl Date1904 { 15 | pub fn get_val(&self) -> &bool { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: bool) -> &mut Date1904 { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:date1904 34 | write_start_tag( 35 | writer, 36 | "c:date1904", 37 | vec![("val", self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/delete.rs: -------------------------------------------------------------------------------- 1 | // c:delete 2 | use super::super::super::BooleanValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct Delete { 12 | val: BooleanValue, 13 | } 14 | impl Delete { 15 | pub fn get_val(&self) -> &bool { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: bool) -> &mut Delete { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:delete 34 | write_start_tag( 35 | writer, 36 | "c:delete", 37 | vec![("val", self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/display_blanks_as.rs: -------------------------------------------------------------------------------- 1 | // c:dispBlanksAs 2 | use super::super::super::EnumValue; 3 | use super::DisplayBlanksAsValues; 4 | use crate::reader::driver::*; 5 | use crate::writer::driver::*; 6 | use quick_xml::events::BytesStart; 7 | use quick_xml::Reader; 8 | use quick_xml::Writer; 9 | use std::io::Cursor; 10 | 11 | #[derive(Clone, Default, Debug)] 12 | pub struct DisplayBlanksAs { 13 | val: EnumValue, 14 | } 15 | impl DisplayBlanksAs { 16 | pub fn get_val(&self) -> &DisplayBlanksAsValues { 17 | self.val.get_value() 18 | } 19 | 20 | pub fn set_val(&mut self, value: DisplayBlanksAsValues) -> &mut DisplayBlanksAs { 21 | self.val.set_value(value); 22 | self 23 | } 24 | 25 | pub(crate) fn set_attributes( 26 | &mut self, 27 | _reader: &mut Reader, 28 | e: &BytesStart, 29 | ) { 30 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 31 | } 32 | 33 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 34 | // c:dispBlanksAs 35 | write_start_tag( 36 | writer, 37 | "c:dispBlanksAs", 38 | vec![("val", self.val.get_value_string())], 39 | true, 40 | ); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/display_blanks_as_values.rs: -------------------------------------------------------------------------------- 1 | use super::super::super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug)] 4 | pub enum DisplayBlanksAsValues { 5 | Gap, 6 | Span, 7 | Zero, 8 | } 9 | impl Default for DisplayBlanksAsValues { 10 | fn default() -> Self { 11 | Self::Span 12 | } 13 | } 14 | impl EnumTrait for DisplayBlanksAsValues { 15 | fn get_value_string(&self) -> &str { 16 | match &self { 17 | Self::Gap => "gap", 18 | Self::Span => "span", 19 | Self::Zero => "zero", 20 | } 21 | } 22 | } 23 | impl FromStr for DisplayBlanksAsValues { 24 | type Err = (); 25 | fn from_str(input: &str) -> Result { 26 | match input { 27 | "gap" => Ok(Self::Gap), 28 | "span" => Ok(Self::Span), 29 | "zero" => Ok(Self::Zero), 30 | _ => Err(()), 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/editing_language.rs: -------------------------------------------------------------------------------- 1 | // c:lang 2 | use super::super::super::StringValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct EditingLanguage { 12 | val: StringValue, 13 | } 14 | impl EditingLanguage { 15 | pub fn get_val(&self) -> &str { 16 | self.val.get_value_str() 17 | } 18 | 19 | pub fn set_val>(&mut self, value: S) -> &mut EditingLanguage { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:lang 34 | write_start_tag( 35 | writer, 36 | "c:lang", 37 | vec![("val", self.val.get_value_str())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/explosion.rs: -------------------------------------------------------------------------------- 1 | // c:explosion 2 | use super::super::super::UInt32Value; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct Explosion { 12 | val: UInt32Value, 13 | } 14 | impl Explosion { 15 | pub fn get_val(&self) -> &u32 { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: u32) -> &mut Explosion { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:explosion 34 | write_start_tag( 35 | writer, 36 | "c:explosion", 37 | vec![("val", &self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/first_slice_angle.rs: -------------------------------------------------------------------------------- 1 | // c:firstSliceAng 2 | use super::super::super::UInt16Value; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct FirstSliceAngle { 12 | val: UInt16Value, 13 | } 14 | impl FirstSliceAngle { 15 | pub fn get_val(&self) -> &u16 { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: u16) -> &mut FirstSliceAngle { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:firstSliceAng 34 | write_start_tag( 35 | writer, 36 | "c:firstSliceAng", 37 | vec![("val", &self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/gap_width.rs: -------------------------------------------------------------------------------- 1 | // c:gapWidth 2 | use super::super::super::UInt16Value; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct GapWidth { 12 | val: UInt16Value, 13 | } 14 | impl GapWidth { 15 | pub fn get_val(&self) -> &u16 { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: u16) -> &mut GapWidth { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:gapWidth 34 | write_start_tag( 35 | writer, 36 | "c:gapWidth", 37 | vec![("val", &self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/grouping.rs: -------------------------------------------------------------------------------- 1 | // c:grouping 2 | use super::super::super::EnumValue; 3 | use super::GroupingValues; 4 | use crate::reader::driver::*; 5 | use crate::writer::driver::*; 6 | use quick_xml::events::BytesStart; 7 | use quick_xml::Reader; 8 | use quick_xml::Writer; 9 | use std::io::Cursor; 10 | 11 | #[derive(Clone, Default, Debug)] 12 | pub struct Grouping { 13 | val: EnumValue, 14 | } 15 | impl Grouping { 16 | pub fn get_val(&self) -> &GroupingValues { 17 | self.val.get_value() 18 | } 19 | 20 | pub fn set_val(&mut self, value: GroupingValues) -> &mut Grouping { 21 | self.val.set_value(value); 22 | self 23 | } 24 | 25 | pub(crate) fn set_attributes( 26 | &mut self, 27 | _reader: &mut Reader, 28 | e: &BytesStart, 29 | ) { 30 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 31 | } 32 | 33 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 34 | // c:grouping 35 | write_start_tag( 36 | writer, 37 | "c:grouping", 38 | vec![("val", self.val.get_value_string())], 39 | true, 40 | ); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/grouping_values.rs: -------------------------------------------------------------------------------- 1 | use super::super::super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug)] 4 | pub enum GroupingValues { 5 | PercentStacked, 6 | Stacked, 7 | Standard, 8 | } 9 | impl Default for GroupingValues { 10 | fn default() -> Self { 11 | Self::PercentStacked 12 | } 13 | } 14 | impl EnumTrait for GroupingValues { 15 | fn get_value_string(&self) -> &str { 16 | match &self { 17 | Self::PercentStacked => "percentStacked", 18 | Self::Stacked => "stacked", 19 | Self::Standard => "standard", 20 | } 21 | } 22 | } 23 | impl FromStr for GroupingValues { 24 | type Err = (); 25 | fn from_str(input: &str) -> Result { 26 | match input { 27 | "percentStacked" => Ok(Self::PercentStacked), 28 | "stacked" => Ok(Self::Stacked), 29 | "standard" => Ok(Self::Standard), 30 | _ => Err(()), 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/header_footer.rs: -------------------------------------------------------------------------------- 1 | // c:headerFooter 2 | use crate::writer::driver::*; 3 | use quick_xml::events::BytesStart; 4 | use quick_xml::Reader; 5 | use quick_xml::Writer; 6 | use std::io::Cursor; 7 | 8 | #[derive(Clone, Default, Debug)] 9 | pub struct HeaderFooter {} 10 | impl HeaderFooter { 11 | pub(crate) fn set_attributes( 12 | &mut self, 13 | _reader: &mut Reader, 14 | _e: &BytesStart, 15 | ) { 16 | } 17 | 18 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 19 | // c:headerFooter 20 | write_start_tag(writer, "c:headerFooter", vec![], true); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/height.rs: -------------------------------------------------------------------------------- 1 | // c:h 2 | use super::super::super::DoubleValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct Height { 12 | val: DoubleValue, 13 | } 14 | impl Height { 15 | pub fn get_val(&self) -> &f64 { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: f64) -> &mut Height { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:h 34 | write_start_tag( 35 | writer, 36 | "c:h", 37 | vec![("val", &self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/height_mode.rs: -------------------------------------------------------------------------------- 1 | // c:hMode 2 | use super::super::super::EnumValue; 3 | use super::LayoutModeValues; 4 | use crate::reader::driver::*; 5 | use crate::writer::driver::*; 6 | use quick_xml::events::BytesStart; 7 | use quick_xml::Reader; 8 | use quick_xml::Writer; 9 | use std::io::Cursor; 10 | 11 | #[derive(Clone, Default, Debug)] 12 | pub struct HeightMode { 13 | val: EnumValue, 14 | } 15 | impl HeightMode { 16 | pub fn get_val(&self) -> &LayoutModeValues { 17 | self.val.get_value() 18 | } 19 | 20 | pub fn set_val(&mut self, value: LayoutModeValues) -> &mut HeightMode { 21 | self.val.set_value(value); 22 | self 23 | } 24 | 25 | pub(crate) fn set_attributes( 26 | &mut self, 27 | _reader: &mut Reader, 28 | e: &BytesStart, 29 | ) { 30 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 31 | } 32 | 33 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 34 | // c:hMode 35 | write_start_tag( 36 | writer, 37 | "c:hMode", 38 | vec![("val", self.val.get_value_string())], 39 | true, 40 | ); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/hole_size.rs: -------------------------------------------------------------------------------- 1 | // c:holeSize 2 | use super::super::super::ByteValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct HoleSize { 12 | val: ByteValue, 13 | } 14 | impl HoleSize { 15 | pub fn get_val(&self) -> &u8 { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: u8) -> &mut HoleSize { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:holeSize 34 | write_start_tag( 35 | writer, 36 | "c:holeSize", 37 | vec![("val", &self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/index.rs: -------------------------------------------------------------------------------- 1 | // c:idx 2 | use super::super::super::UInt32Value; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct Index { 12 | val: UInt32Value, 13 | } 14 | impl Index { 15 | pub fn get_val(&self) -> &u32 { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: u32) -> &mut Index { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:idx 34 | write_start_tag( 35 | writer, 36 | "c:idx", 37 | vec![("val", &self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/invert_if_negative.rs: -------------------------------------------------------------------------------- 1 | // c:invertIfNegative 2 | use super::super::super::DoubleValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct InvertIfNegative { 12 | val: DoubleValue, 13 | } 14 | impl InvertIfNegative { 15 | pub fn get_val(&self) -> &f64 { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: f64) -> &mut InvertIfNegative { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:invertIfNegative 34 | write_start_tag( 35 | writer, 36 | "c:invertIfNegative", 37 | vec![("val", &self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/label_alignment.rs: -------------------------------------------------------------------------------- 1 | // c:lblAlgn 2 | use super::super::super::EnumValue; 3 | use super::LabelAlignmentValues; 4 | use crate::reader::driver::*; 5 | use crate::writer::driver::*; 6 | use quick_xml::events::BytesStart; 7 | use quick_xml::Reader; 8 | use quick_xml::Writer; 9 | use std::io::Cursor; 10 | 11 | #[derive(Clone, Default, Debug)] 12 | pub struct LabelAlignment { 13 | val: EnumValue, 14 | } 15 | impl LabelAlignment { 16 | pub fn get_val(&self) -> &LabelAlignmentValues { 17 | self.val.get_value() 18 | } 19 | 20 | pub fn set_val(&mut self, value: LabelAlignmentValues) -> &mut LabelAlignment { 21 | self.val.set_value(value); 22 | self 23 | } 24 | 25 | pub(crate) fn set_attributes( 26 | &mut self, 27 | _reader: &mut Reader, 28 | e: &BytesStart, 29 | ) { 30 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 31 | } 32 | 33 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 34 | // c:lblAlgn 35 | write_start_tag( 36 | writer, 37 | "c:lblAlgn", 38 | vec![("val", self.val.get_value_string())], 39 | true, 40 | ); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/label_alignment_values.rs: -------------------------------------------------------------------------------- 1 | use super::super::super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug)] 4 | pub enum LabelAlignmentValues { 5 | Center, 6 | Left, 7 | Right, 8 | } 9 | impl Default for LabelAlignmentValues { 10 | fn default() -> Self { 11 | Self::Center 12 | } 13 | } 14 | impl EnumTrait for LabelAlignmentValues { 15 | fn get_value_string(&self) -> &str { 16 | match &self { 17 | Self::Center => "ctr", 18 | Self::Left => "l", 19 | Self::Right => "r", 20 | } 21 | } 22 | } 23 | impl FromStr for LabelAlignmentValues { 24 | type Err = (); 25 | fn from_str(input: &str) -> Result { 26 | match input { 27 | "ctr" => Ok(Self::Center), 28 | "l" => Ok(Self::Left), 29 | "r" => Ok(Self::Right), 30 | _ => Err(()), 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/label_offset.rs: -------------------------------------------------------------------------------- 1 | // c:lblOffset 2 | use super::super::super::UInt16Value; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct LabelOffset { 12 | val: UInt16Value, 13 | } 14 | impl LabelOffset { 15 | pub fn get_val(&self) -> &u16 { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: u16) -> &mut LabelOffset { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:lblOffset 34 | write_start_tag( 35 | writer, 36 | "c:lblOffset", 37 | vec![("val", &self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/layout_mode_values.rs: -------------------------------------------------------------------------------- 1 | use super::super::super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug)] 4 | pub enum LayoutModeValues { 5 | Edge, 6 | Factor, 7 | } 8 | impl Default for LayoutModeValues { 9 | fn default() -> Self { 10 | Self::Edge 11 | } 12 | } 13 | impl EnumTrait for LayoutModeValues { 14 | fn get_value_string(&self) -> &str { 15 | match &self { 16 | Self::Edge => "edge", 17 | Self::Factor => "factor", 18 | } 19 | } 20 | } 21 | impl FromStr for LayoutModeValues { 22 | type Err = (); 23 | fn from_str(input: &str) -> Result { 24 | match input { 25 | "edge" => Ok(Self::Edge), 26 | "factor" => Ok(Self::Factor), 27 | _ => Err(()), 28 | } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/layout_target.rs: -------------------------------------------------------------------------------- 1 | // c:layoutTarget 2 | use super::super::super::EnumValue; 3 | use super::LayoutTargetValues; 4 | use crate::reader::driver::*; 5 | use crate::writer::driver::*; 6 | use quick_xml::events::BytesStart; 7 | use quick_xml::Reader; 8 | use quick_xml::Writer; 9 | use std::io::Cursor; 10 | 11 | #[derive(Clone, Default, Debug)] 12 | pub struct LayoutTarget { 13 | val: EnumValue, 14 | } 15 | impl LayoutTarget { 16 | pub fn get_val(&self) -> &LayoutTargetValues { 17 | self.val.get_value() 18 | } 19 | 20 | pub fn set_val(&mut self, value: LayoutTargetValues) -> &mut LayoutTarget { 21 | self.val.set_value(value); 22 | self 23 | } 24 | 25 | pub(crate) fn set_attributes( 26 | &mut self, 27 | _reader: &mut Reader, 28 | e: &BytesStart, 29 | ) { 30 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 31 | } 32 | 33 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 34 | // c:layoutTarget 35 | write_start_tag( 36 | writer, 37 | "c:layoutTarget", 38 | vec![("val", self.val.get_value_string())], 39 | true, 40 | ); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/layout_target_values.rs: -------------------------------------------------------------------------------- 1 | use super::super::super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug)] 4 | pub enum LayoutTargetValues { 5 | Inner, 6 | Outer, 7 | } 8 | impl Default for LayoutTargetValues { 9 | fn default() -> Self { 10 | Self::Inner 11 | } 12 | } 13 | impl EnumTrait for LayoutTargetValues { 14 | fn get_value_string(&self) -> &str { 15 | match &self { 16 | Self::Inner => "inner", 17 | Self::Outer => "outer", 18 | } 19 | } 20 | } 21 | impl FromStr for LayoutTargetValues { 22 | type Err = (); 23 | fn from_str(input: &str) -> Result { 24 | match input { 25 | "inner" => Ok(Self::Inner), 26 | "outer" => Ok(Self::Outer), 27 | _ => Err(()), 28 | } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/left.rs: -------------------------------------------------------------------------------- 1 | // c:x 2 | use super::super::super::DoubleValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct Left { 12 | val: DoubleValue, 13 | } 14 | impl Left { 15 | pub fn get_val(&self) -> &f64 { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: f64) -> &mut Left { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:x 34 | write_start_tag( 35 | writer, 36 | "c:x", 37 | vec![("val", &self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/left_mode.rs: -------------------------------------------------------------------------------- 1 | // c:xMode 2 | use super::super::super::EnumValue; 3 | use super::LayoutModeValues; 4 | use crate::reader::driver::*; 5 | use crate::writer::driver::*; 6 | use quick_xml::events::BytesStart; 7 | use quick_xml::Reader; 8 | use quick_xml::Writer; 9 | use std::io::Cursor; 10 | 11 | #[derive(Clone, Default, Debug)] 12 | pub struct LeftMode { 13 | val: EnumValue, 14 | } 15 | impl LeftMode { 16 | pub fn get_val(&self) -> &LayoutModeValues { 17 | self.val.get_value() 18 | } 19 | 20 | pub fn set_val(&mut self, value: LayoutModeValues) -> &mut LeftMode { 21 | self.val.set_value(value); 22 | self 23 | } 24 | 25 | pub(crate) fn set_attributes( 26 | &mut self, 27 | _reader: &mut Reader, 28 | e: &BytesStart, 29 | ) { 30 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 31 | } 32 | 33 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 34 | // c:xMode 35 | write_start_tag( 36 | writer, 37 | "c:xMode", 38 | vec![("val", self.val.get_value_string())], 39 | true, 40 | ); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/legend_position.rs: -------------------------------------------------------------------------------- 1 | // c:legendPos 2 | use super::super::super::EnumValue; 3 | use super::LegendPositionValues; 4 | use crate::reader::driver::*; 5 | use crate::writer::driver::*; 6 | use quick_xml::events::BytesStart; 7 | use quick_xml::Reader; 8 | use quick_xml::Writer; 9 | use std::io::Cursor; 10 | 11 | #[derive(Clone, Default, Debug)] 12 | pub struct LegendPosition { 13 | val: EnumValue, 14 | } 15 | impl LegendPosition { 16 | pub fn get_val(&self) -> &LegendPositionValues { 17 | self.val.get_value() 18 | } 19 | 20 | pub fn set_val(&mut self, value: LegendPositionValues) -> &mut LegendPosition { 21 | self.val.set_value(value); 22 | self 23 | } 24 | 25 | pub(crate) fn set_attributes( 26 | &mut self, 27 | _reader: &mut Reader, 28 | e: &BytesStart, 29 | ) { 30 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 31 | } 32 | 33 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 34 | // c:legendPos 35 | write_start_tag( 36 | writer, 37 | "c:legendPos", 38 | vec![("val", self.val.get_value_string())], 39 | true, 40 | ); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/legend_position_values.rs: -------------------------------------------------------------------------------- 1 | use super::super::super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug)] 4 | pub enum LegendPositionValues { 5 | Bottom, 6 | Left, 7 | Right, 8 | Top, 9 | TopRight, 10 | } 11 | impl Default for LegendPositionValues { 12 | fn default() -> Self { 13 | Self::Bottom 14 | } 15 | } 16 | impl EnumTrait for LegendPositionValues { 17 | fn get_value_string(&self) -> &str { 18 | match &self { 19 | Self::Bottom => "b", 20 | Self::Left => "l", 21 | Self::Right => "r", 22 | Self::Top => "t", 23 | Self::TopRight => "tr", 24 | } 25 | } 26 | } 27 | impl FromStr for LegendPositionValues { 28 | type Err = (); 29 | fn from_str(input: &str) -> Result { 30 | match input { 31 | "b" => Ok(Self::Bottom), 32 | "l" => Ok(Self::Left), 33 | "r" => Ok(Self::Right), 34 | "t" => Ok(Self::Top), 35 | "tr" => Ok(Self::TopRight), 36 | _ => Err(()), 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/major_tick_mark.rs: -------------------------------------------------------------------------------- 1 | // c:majorTickMark 2 | use super::super::super::EnumValue; 3 | use super::TickMarkValues; 4 | use crate::reader::driver::*; 5 | use crate::writer::driver::*; 6 | use quick_xml::events::BytesStart; 7 | use quick_xml::Reader; 8 | use quick_xml::Writer; 9 | use std::io::Cursor; 10 | 11 | #[derive(Clone, Default, Debug)] 12 | pub struct MajorTickMark { 13 | val: EnumValue, 14 | } 15 | impl MajorTickMark { 16 | pub fn get_val(&self) -> &TickMarkValues { 17 | self.val.get_value() 18 | } 19 | 20 | pub fn set_val(&mut self, value: TickMarkValues) -> &mut MajorTickMark { 21 | self.val.set_value(value); 22 | self 23 | } 24 | 25 | pub(crate) fn set_attributes( 26 | &mut self, 27 | _reader: &mut Reader, 28 | e: &BytesStart, 29 | ) { 30 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 31 | } 32 | 33 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 34 | // c:majorTickMark 35 | write_start_tag( 36 | writer, 37 | "c:majorTickMark", 38 | vec![("val", self.val.get_value_string())], 39 | true, 40 | ); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/minor_tick_mark.rs: -------------------------------------------------------------------------------- 1 | // c:minorTickMark 2 | use super::super::super::EnumValue; 3 | use super::TickMarkValues; 4 | use crate::reader::driver::*; 5 | use crate::writer::driver::*; 6 | use quick_xml::events::BytesStart; 7 | use quick_xml::Reader; 8 | use quick_xml::Writer; 9 | use std::io::Cursor; 10 | 11 | #[derive(Clone, Default, Debug)] 12 | pub struct MinorTickMark { 13 | val: EnumValue, 14 | } 15 | impl MinorTickMark { 16 | pub fn get_val(&self) -> &TickMarkValues { 17 | self.val.get_value() 18 | } 19 | 20 | pub fn set_val(&mut self, value: TickMarkValues) -> &mut MinorTickMark { 21 | self.val.set_value(value); 22 | self 23 | } 24 | 25 | pub(crate) fn set_attributes( 26 | &mut self, 27 | _reader: &mut Reader, 28 | e: &BytesStart, 29 | ) { 30 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 31 | } 32 | 33 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 34 | // c:minorTickMark 35 | write_start_tag( 36 | writer, 37 | "c:minorTickMark", 38 | vec![("val", self.val.get_value_string())], 39 | true, 40 | ); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/no_multi_level_labels.rs: -------------------------------------------------------------------------------- 1 | // c:noMultiLvlLbl 2 | use super::super::super::BooleanValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct NoMultiLevelLabels { 12 | val: BooleanValue, 13 | } 14 | impl NoMultiLevelLabels { 15 | pub fn get_val(&self) -> &bool { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: bool) -> &mut NoMultiLevelLabels { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:noMultiLvlLbl 34 | write_start_tag( 35 | writer, 36 | "c:noMultiLvlLbl", 37 | vec![("val", self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/of_pie_type.rs: -------------------------------------------------------------------------------- 1 | // c:ofPieType 2 | use super::super::super::EnumValue; 3 | use super::OfPieValues; 4 | use crate::reader::driver::*; 5 | use crate::writer::driver::*; 6 | use quick_xml::events::BytesStart; 7 | use quick_xml::Reader; 8 | use quick_xml::Writer; 9 | use std::io::Cursor; 10 | 11 | #[derive(Clone, Default, Debug)] 12 | pub struct OfPieType { 13 | val: EnumValue, 14 | } 15 | impl OfPieType { 16 | pub fn get_val(&self) -> &OfPieValues { 17 | self.val.get_value() 18 | } 19 | 20 | pub fn set_val(&mut self, value: OfPieValues) -> &mut OfPieType { 21 | self.val.set_value(value); 22 | self 23 | } 24 | 25 | pub(crate) fn set_attributes( 26 | &mut self, 27 | _reader: &mut Reader, 28 | e: &BytesStart, 29 | ) { 30 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 31 | } 32 | 33 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 34 | // c:ofPieType 35 | write_start_tag( 36 | writer, 37 | "c:ofPieType", 38 | vec![("val", self.val.get_value_string())], 39 | true, 40 | ); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/of_pie_values.rs: -------------------------------------------------------------------------------- 1 | use super::super::super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug)] 4 | pub enum OfPieValues { 5 | Bar, 6 | Pie, 7 | } 8 | impl Default for OfPieValues { 9 | fn default() -> Self { 10 | Self::Pie 11 | } 12 | } 13 | impl EnumTrait for OfPieValues { 14 | fn get_value_string(&self) -> &str { 15 | match &self { 16 | Self::Bar => "bar", 17 | Self::Pie => "pie", 18 | } 19 | } 20 | } 21 | impl FromStr for OfPieValues { 22 | type Err = (); 23 | fn from_str(input: &str) -> Result { 24 | match input { 25 | "bar" => Ok(Self::Bar), 26 | "pie" => Ok(Self::Pie), 27 | _ => Err(()), 28 | } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/order.rs: -------------------------------------------------------------------------------- 1 | // c:order 2 | use super::super::super::UInt32Value; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct Order { 12 | val: UInt32Value, 13 | } 14 | impl Order { 15 | pub fn get_val(&self) -> &u32 { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: u32) -> &mut Order { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:order 34 | write_start_tag( 35 | writer, 36 | "c:order", 37 | vec![("val", &self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/orientation.rs: -------------------------------------------------------------------------------- 1 | // c:orientation 2 | use super::super::super::EnumValue; 3 | use super::OrientationValues; 4 | use crate::reader::driver::*; 5 | use crate::writer::driver::*; 6 | use quick_xml::events::BytesStart; 7 | use quick_xml::Reader; 8 | use quick_xml::Writer; 9 | use std::io::Cursor; 10 | 11 | #[derive(Clone, Default, Debug)] 12 | pub struct Orientation { 13 | val: EnumValue, 14 | } 15 | impl Orientation { 16 | pub fn get_val(&self) -> &OrientationValues { 17 | self.val.get_value() 18 | } 19 | 20 | pub fn set_val(&mut self, value: OrientationValues) -> &mut Orientation { 21 | self.val.set_value(value); 22 | self 23 | } 24 | 25 | pub(crate) fn set_attributes( 26 | &mut self, 27 | _reader: &mut Reader, 28 | e: &BytesStart, 29 | ) { 30 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 31 | } 32 | 33 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 34 | // c:orientation 35 | write_start_tag( 36 | writer, 37 | "c:orientation", 38 | vec![("val", self.val.get_value_string())], 39 | true, 40 | ); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/orientation_values.rs: -------------------------------------------------------------------------------- 1 | use super::super::super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug)] 4 | pub enum OrientationValues { 5 | MaxMin, 6 | MinMax, 7 | } 8 | impl Default for OrientationValues { 9 | fn default() -> Self { 10 | Self::MaxMin 11 | } 12 | } 13 | impl EnumTrait for OrientationValues { 14 | fn get_value_string(&self) -> &str { 15 | match &self { 16 | Self::MaxMin => "maxMin", 17 | Self::MinMax => "minMax", 18 | } 19 | } 20 | } 21 | impl FromStr for OrientationValues { 22 | type Err = (); 23 | fn from_str(input: &str) -> Result { 24 | match input { 25 | "maxMin" => Ok(Self::MaxMin), 26 | "minMax" => Ok(Self::MinMax), 27 | _ => Err(()), 28 | } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/overlap.rs: -------------------------------------------------------------------------------- 1 | // c:overlap 2 | use super::super::super::SByteValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct Overlap { 12 | val: SByteValue, 13 | } 14 | impl Overlap { 15 | pub fn get_val(&self) -> &i8 { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: i8) -> &mut Overlap { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:overlap 34 | write_start_tag( 35 | writer, 36 | "c:overlap", 37 | vec![("val", &self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/overlay.rs: -------------------------------------------------------------------------------- 1 | // c:overlay 2 | use super::super::super::BooleanValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct Overlay { 12 | val: BooleanValue, 13 | } 14 | impl Overlay { 15 | pub fn get_val(&self) -> &bool { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: bool) -> &mut Overlay { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:overlay 34 | write_start_tag( 35 | writer, 36 | "c:overlay", 37 | vec![("val", self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/page_setup.rs: -------------------------------------------------------------------------------- 1 | // c:pageSetup 2 | use crate::writer::driver::*; 3 | use quick_xml::events::BytesStart; 4 | use quick_xml::Reader; 5 | use quick_xml::Writer; 6 | use std::io::Cursor; 7 | 8 | #[derive(Clone, Default, Debug)] 9 | pub struct PageSetup {} 10 | impl PageSetup { 11 | pub(crate) fn set_attributes( 12 | &mut self, 13 | _reader: &mut Reader, 14 | _e: &BytesStart, 15 | ) { 16 | } 17 | 18 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 19 | // c:pageSetup 20 | write_start_tag(writer, "c:pageSetup", vec![], true); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/perspective.rs: -------------------------------------------------------------------------------- 1 | // c:perspective 2 | use super::super::super::ByteValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct Perspective { 12 | val: ByteValue, 13 | } 14 | impl Perspective { 15 | pub fn get_val(&self) -> &u8 { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: u8) -> &mut Perspective { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:perspective 34 | write_start_tag( 35 | writer, 36 | "c:perspective", 37 | vec![("val", &self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/plot_visible_only.rs: -------------------------------------------------------------------------------- 1 | // c:plotVisOnly 2 | use super::super::super::BooleanValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct PlotVisibleOnly { 12 | val: BooleanValue, 13 | } 14 | impl PlotVisibleOnly { 15 | pub fn get_val(&self) -> &bool { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: bool) -> &mut PlotVisibleOnly { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:plotVisOnly 34 | write_start_tag( 35 | writer, 36 | "c:plotVisOnly", 37 | vec![("val", self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/radar_style.rs: -------------------------------------------------------------------------------- 1 | // c:radarStyle 2 | use super::super::super::EnumValue; 3 | use super::RadarStyleValues; 4 | use crate::reader::driver::*; 5 | use crate::writer::driver::*; 6 | use quick_xml::events::BytesStart; 7 | use quick_xml::Reader; 8 | use quick_xml::Writer; 9 | use std::io::Cursor; 10 | 11 | #[derive(Clone, Default, Debug)] 12 | pub struct RadarStyle { 13 | val: EnumValue, 14 | } 15 | impl RadarStyle { 16 | pub fn get_val(&self) -> &RadarStyleValues { 17 | self.val.get_value() 18 | } 19 | 20 | pub fn set_val(&mut self, value: RadarStyleValues) -> &mut RadarStyle { 21 | self.val.set_value(value); 22 | self 23 | } 24 | 25 | pub(crate) fn set_attributes( 26 | &mut self, 27 | _reader: &mut Reader, 28 | e: &BytesStart, 29 | ) { 30 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 31 | } 32 | 33 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 34 | // c:radarStyle 35 | write_start_tag( 36 | writer, 37 | "c:radarStyle", 38 | vec![("val", self.val.get_value_string())], 39 | true, 40 | ); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/radar_style_values.rs: -------------------------------------------------------------------------------- 1 | use super::super::super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug)] 4 | pub enum RadarStyleValues { 5 | Filled, 6 | Marker, 7 | Standard, 8 | } 9 | impl Default for RadarStyleValues { 10 | fn default() -> Self { 11 | Self::Standard 12 | } 13 | } 14 | impl EnumTrait for RadarStyleValues { 15 | fn get_value_string(&self) -> &str { 16 | match &self { 17 | Self::Filled => "filled", 18 | Self::Marker => "marker", 19 | Self::Standard => "standard", 20 | } 21 | } 22 | } 23 | impl FromStr for RadarStyleValues { 24 | type Err = (); 25 | fn from_str(input: &str) -> Result { 26 | match input { 27 | "filled" => Ok(Self::Filled), 28 | "marker" => Ok(Self::Marker), 29 | "standard" => Ok(Self::Standard), 30 | _ => Err(()), 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/right_angle_axes.rs: -------------------------------------------------------------------------------- 1 | // c:rAngAx 2 | use super::super::super::BooleanValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct RightAngleAxes { 12 | val: BooleanValue, 13 | } 14 | impl RightAngleAxes { 15 | pub fn get_val(&self) -> &bool { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: bool) -> &mut RightAngleAxes { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:rAngAx 34 | write_start_tag( 35 | writer, 36 | "c:rAngAx", 37 | vec![("val", self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/rotate_x.rs: -------------------------------------------------------------------------------- 1 | // c:rotX 2 | use super::super::super::SByteValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct RotateX { 12 | val: SByteValue, 13 | } 14 | impl RotateX { 15 | pub fn get_val(&self) -> &i8 { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: i8) -> &mut RotateX { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:rotX 34 | write_start_tag( 35 | writer, 36 | "c:rotX", 37 | vec![("val", &self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/rotate_y.rs: -------------------------------------------------------------------------------- 1 | // c:rotY 2 | use super::super::super::UInt16Value; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct RotateY { 12 | val: UInt16Value, 13 | } 14 | impl RotateY { 15 | pub fn get_val(&self) -> &u16 { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: u16) -> &mut RotateY { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:rotY 34 | write_start_tag( 35 | writer, 36 | "c:rotY", 37 | vec![("val", &self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/rounded_corners.rs: -------------------------------------------------------------------------------- 1 | // c:roundedCorners 2 | use super::super::super::BooleanValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct RoundedCorners { 12 | val: BooleanValue, 13 | } 14 | impl RoundedCorners { 15 | pub fn get_val(&self) -> &bool { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: bool) -> &mut RoundedCorners { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:roundedCorners 34 | write_start_tag( 35 | writer, 36 | "c:roundedCorners", 37 | vec![("val", self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/scatter_style.rs: -------------------------------------------------------------------------------- 1 | // c:scatterStyle 2 | use super::super::super::EnumValue; 3 | use super::ScatterStyleValues; 4 | use crate::reader::driver::*; 5 | use crate::writer::driver::*; 6 | use quick_xml::events::BytesStart; 7 | use quick_xml::Reader; 8 | use quick_xml::Writer; 9 | use std::io::Cursor; 10 | 11 | #[derive(Clone, Default, Debug)] 12 | pub struct ScatterStyle { 13 | val: EnumValue, 14 | } 15 | impl ScatterStyle { 16 | pub fn get_val(&self) -> &ScatterStyleValues { 17 | self.val.get_value() 18 | } 19 | 20 | pub fn set_val(&mut self, value: ScatterStyleValues) -> &mut ScatterStyle { 21 | self.val.set_value(value); 22 | self 23 | } 24 | 25 | pub(crate) fn set_attributes( 26 | &mut self, 27 | _reader: &mut Reader, 28 | e: &BytesStart, 29 | ) { 30 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 31 | } 32 | 33 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 34 | // c:scatterStyle 35 | write_start_tag( 36 | writer, 37 | "c:scatterStyle", 38 | vec![("val", self.val.get_value_string())], 39 | true, 40 | ); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/scatter_style_values.rs: -------------------------------------------------------------------------------- 1 | use super::super::super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug)] 4 | pub enum ScatterStyleValues { 5 | Line, 6 | LineMarker, 7 | Marker, 8 | Smooth, 9 | SmoothMarker, 10 | } 11 | impl Default for ScatterStyleValues { 12 | fn default() -> Self { 13 | Self::Line 14 | } 15 | } 16 | impl EnumTrait for ScatterStyleValues { 17 | fn get_value_string(&self) -> &str { 18 | match &self { 19 | Self::Line => "line", 20 | Self::LineMarker => "lineMarker", 21 | Self::Marker => "marker", 22 | Self::Smooth => "smooth", 23 | Self::SmoothMarker => "smoothMarker", 24 | } 25 | } 26 | } 27 | impl FromStr for ScatterStyleValues { 28 | type Err = (); 29 | fn from_str(input: &str) -> Result { 30 | match input { 31 | "line" => Ok(Self::Line), 32 | "lineMarker" => Ok(Self::LineMarker), 33 | "marker" => Ok(Self::Marker), 34 | "smooth" => Ok(Self::Smooth), 35 | "smoothMarker" => Ok(Self::SmoothMarker), 36 | _ => Err(()), 37 | } 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/second_pie_size.rs: -------------------------------------------------------------------------------- 1 | // c:secondPieSize 2 | use super::super::super::UInt16Value; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct SecondPieSize { 12 | val: UInt16Value, 13 | } 14 | impl SecondPieSize { 15 | pub fn get_val(&self) -> &u16 { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: u16) -> &mut SecondPieSize { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:secondPieSize 34 | write_start_tag( 35 | writer, 36 | "c:secondPieSize", 37 | vec![("val", &self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/series_lines.rs: -------------------------------------------------------------------------------- 1 | // c:serLines 2 | use crate::writer::driver::*; 3 | use quick_xml::events::BytesStart; 4 | use quick_xml::Reader; 5 | use quick_xml::Writer; 6 | use std::io::Cursor; 7 | 8 | #[derive(Clone, Default, Debug)] 9 | pub struct SeriesLines {} 10 | impl SeriesLines { 11 | pub(crate) fn set_attributes( 12 | &mut self, 13 | _reader: &mut Reader, 14 | _e: &BytesStart, 15 | ) { 16 | } 17 | 18 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 19 | // c:serLines 20 | write_start_tag(writer, "c:serLines", vec![], true); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/shape.rs: -------------------------------------------------------------------------------- 1 | // c:shape 2 | use super::super::super::EnumValue; 3 | use super::ShapeValues; 4 | use crate::reader::driver::*; 5 | use crate::writer::driver::*; 6 | use quick_xml::events::BytesStart; 7 | use quick_xml::Reader; 8 | use quick_xml::Writer; 9 | use std::io::Cursor; 10 | 11 | #[derive(Clone, Default, Debug)] 12 | pub struct Shape { 13 | val: EnumValue, 14 | } 15 | impl Shape { 16 | pub fn get_val(&self) -> &ShapeValues { 17 | self.val.get_value() 18 | } 19 | 20 | pub fn set_val(&mut self, value: ShapeValues) -> &mut Shape { 21 | self.val.set_value(value); 22 | self 23 | } 24 | 25 | pub(crate) fn set_attributes( 26 | &mut self, 27 | _reader: &mut Reader, 28 | e: &BytesStart, 29 | ) { 30 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 31 | } 32 | 33 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 34 | // c:shape 35 | write_start_tag( 36 | writer, 37 | "c:shape", 38 | vec![("val", self.val.get_value_string())], 39 | true, 40 | ); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/shape_values.rs: -------------------------------------------------------------------------------- 1 | use super::super::super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug)] 4 | pub enum ShapeValues { 5 | Box, 6 | Cone, 7 | ConeToMax, 8 | Cylinder, 9 | Pyramid, 10 | PyramidToMaximum, 11 | } 12 | impl Default for ShapeValues { 13 | fn default() -> Self { 14 | Self::Cone 15 | } 16 | } 17 | impl EnumTrait for ShapeValues { 18 | fn get_value_string(&self) -> &str { 19 | match &self { 20 | Self::Box => "box", 21 | Self::Cone => "cone", 22 | Self::ConeToMax => "coneToMax", 23 | Self::Cylinder => "cylinder", 24 | Self::Pyramid => "pyramid", 25 | Self::PyramidToMaximum => "pyramidToMax", 26 | } 27 | } 28 | } 29 | impl FromStr for ShapeValues { 30 | type Err = (); 31 | fn from_str(input: &str) -> Result { 32 | match input { 33 | "box" => Ok(Self::Box), 34 | "cone" => Ok(Self::Cone), 35 | "coneToMax" => Ok(Self::ConeToMax), 36 | "cylinder" => Ok(Self::Cylinder), 37 | "pyramid" => Ok(Self::Pyramid), 38 | "pyramidToMax" => Ok(Self::PyramidToMaximum), 39 | _ => Err(()), 40 | } 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/show_bubble_size.rs: -------------------------------------------------------------------------------- 1 | // c:showBubbleSize 2 | use super::super::super::BooleanValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct ShowBubbleSize { 12 | val: BooleanValue, 13 | } 14 | impl ShowBubbleSize { 15 | pub fn get_val(&self) -> &bool { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: bool) -> &mut ShowBubbleSize { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:showBubbleSize 34 | write_start_tag( 35 | writer, 36 | "c:showBubbleSize", 37 | vec![("val", self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/show_category_name.rs: -------------------------------------------------------------------------------- 1 | // c:showCatName 2 | use super::super::super::BooleanValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct ShowCategoryName { 12 | val: BooleanValue, 13 | } 14 | impl ShowCategoryName { 15 | pub fn get_val(&self) -> &bool { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: bool) -> &mut ShowCategoryName { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:showCatName 34 | write_start_tag( 35 | writer, 36 | "c:showCatName", 37 | vec![("val", self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/show_data_labels_over_maximum.rs: -------------------------------------------------------------------------------- 1 | // c:showDLblsOverMax 2 | use super::super::super::BooleanValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct ShowDataLabelsOverMaximum { 12 | val: BooleanValue, 13 | } 14 | impl ShowDataLabelsOverMaximum { 15 | pub fn get_val(&self) -> &bool { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: bool) -> &mut ShowDataLabelsOverMaximum { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:showDLblsOverMax 34 | write_start_tag( 35 | writer, 36 | "c:showDLblsOverMax", 37 | vec![("val", self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/show_leader_lines.rs: -------------------------------------------------------------------------------- 1 | // c:showLeaderLines 2 | use super::super::super::BooleanValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct ShowLeaderLines { 12 | val: BooleanValue, 13 | } 14 | impl ShowLeaderLines { 15 | pub fn get_val(&self) -> &bool { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: bool) -> &mut ShowLeaderLines { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:showLeaderLines 34 | write_start_tag( 35 | writer, 36 | "c:showLeaderLines", 37 | vec![("val", self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/show_legend_key.rs: -------------------------------------------------------------------------------- 1 | // c:showLegendKey 2 | use super::super::super::BooleanValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct ShowLegendKey { 12 | val: BooleanValue, 13 | } 14 | impl ShowLegendKey { 15 | pub fn get_val(&self) -> &bool { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: bool) -> &mut ShowLegendKey { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:showLegendKey 34 | write_start_tag( 35 | writer, 36 | "c:showLegendKey", 37 | vec![("val", self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/show_marker.rs: -------------------------------------------------------------------------------- 1 | // c:marker 2 | use super::super::super::BooleanValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct ShowMarker { 12 | val: BooleanValue, 13 | } 14 | impl ShowMarker { 15 | pub fn get_val(&self) -> &bool { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: bool) -> &mut ShowMarker { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:marker 34 | write_start_tag( 35 | writer, 36 | "c:marker", 37 | vec![("val", self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/show_negative_bubbles.rs: -------------------------------------------------------------------------------- 1 | // c:showNegBubbles 2 | use super::super::super::BooleanValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct ShowNegativeBubbles { 12 | val: BooleanValue, 13 | } 14 | impl ShowNegativeBubbles { 15 | pub fn get_val(&self) -> &bool { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: bool) -> &mut ShowNegativeBubbles { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:showNegBubbles 34 | write_start_tag( 35 | writer, 36 | "c:showNegBubbles", 37 | vec![("val", self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/show_percent.rs: -------------------------------------------------------------------------------- 1 | // c:showPercent 2 | use super::super::super::BooleanValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct ShowPercent { 12 | val: BooleanValue, 13 | } 14 | impl ShowPercent { 15 | pub fn get_val(&self) -> &bool { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: bool) -> &mut ShowPercent { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:showPercent 34 | write_start_tag( 35 | writer, 36 | "c:showPercent", 37 | vec![("val", self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/show_series_name.rs: -------------------------------------------------------------------------------- 1 | // c:showSerName 2 | use super::super::super::BooleanValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct ShowSeriesName { 12 | val: BooleanValue, 13 | } 14 | impl ShowSeriesName { 15 | pub fn get_val(&self) -> &bool { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: bool) -> &mut ShowSeriesName { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:showSerName 34 | write_start_tag( 35 | writer, 36 | "c:showSerName", 37 | vec![("val", self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/show_value.rs: -------------------------------------------------------------------------------- 1 | // c:showVal 2 | use super::super::super::BooleanValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct ShowValue { 12 | val: BooleanValue, 13 | } 14 | impl ShowValue { 15 | pub fn get_val(&self) -> &bool { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: bool) -> &mut ShowValue { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:showVal 34 | write_start_tag( 35 | writer, 36 | "c:showVal", 37 | vec![("val", self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/size.rs: -------------------------------------------------------------------------------- 1 | // c:size 2 | use super::super::super::ByteValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct Size { 12 | val: ByteValue, 13 | } 14 | impl Size { 15 | pub fn get_val(&self) -> &u8 { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: u8) -> &mut Self { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | let val = self.val.get_value_string(); 34 | // c:size 35 | write_start_tag(writer, "c:size", vec![("val", &val)], true); 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/smooth.rs: -------------------------------------------------------------------------------- 1 | // c:smooth 2 | use super::super::super::BooleanValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct Smooth { 12 | val: BooleanValue, 13 | } 14 | impl Smooth { 15 | pub fn get_val(&self) -> &bool { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: bool) -> &mut Self { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:smooth 34 | write_start_tag( 35 | writer, 36 | "c:smooth", 37 | vec![("val", self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/style.rs: -------------------------------------------------------------------------------- 1 | // c:style 2 | use super::super::super::ByteValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Default, Debug)] 11 | pub struct Style { 12 | val: ByteValue, 13 | } 14 | 15 | impl Style { 16 | pub fn get_val(&self) -> &u8 { 17 | self.val.get_value() 18 | } 19 | 20 | pub fn set_val(&mut self, value: u8) -> &mut Style { 21 | self.val.set_value(value); 22 | self 23 | } 24 | 25 | pub(crate) fn _set_attributes( 26 | &mut self, 27 | _reader: &mut Reader, 28 | e: &BytesStart, 29 | ) { 30 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 31 | } 32 | 33 | pub(crate) fn _write_to(&self, writer: &mut Writer>>) { 34 | // c:style 35 | write_start_tag( 36 | writer, 37 | "c:style", 38 | vec![("val", &self.val.get_value_string())], 39 | true, 40 | ); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/symbol.rs: -------------------------------------------------------------------------------- 1 | // c:symbol 2 | use super::super::super::EnumValue; 3 | use super::MarkerStyleValues; 4 | use crate::reader::driver::*; 5 | use crate::writer::driver::*; 6 | use quick_xml::events::BytesStart; 7 | use quick_xml::Reader; 8 | use quick_xml::Writer; 9 | use std::io::Cursor; 10 | 11 | #[derive(Clone, Default, Debug)] 12 | pub struct Symbol { 13 | val: EnumValue, 14 | } 15 | impl Symbol { 16 | pub fn get_val(&self) -> &MarkerStyleValues { 17 | self.val.get_value() 18 | } 19 | 20 | pub fn set_val(&mut self, value: MarkerStyleValues) -> &mut Symbol { 21 | self.val.set_value(value); 22 | self 23 | } 24 | 25 | pub(crate) fn set_attributes( 26 | &mut self, 27 | _reader: &mut Reader, 28 | e: &BytesStart, 29 | ) { 30 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 31 | } 32 | 33 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 34 | // c:symbol 35 | write_start_tag( 36 | writer, 37 | "c:symbol", 38 | vec![("val", self.val.get_value_string())], 39 | true, 40 | ); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/thickness.rs: -------------------------------------------------------------------------------- 1 | // c:thickness 2 | use super::super::super::ByteValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct Thickness { 12 | val: ByteValue, 13 | } 14 | impl Thickness { 15 | pub fn get_val(&self) -> &u8 { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: u8) -> &mut Thickness { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:thickness 34 | write_start_tag( 35 | writer, 36 | "c:thickness", 37 | vec![("val", &self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/tick_label_position_values.rs: -------------------------------------------------------------------------------- 1 | use super::super::super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug)] 4 | pub enum TickLabelPositionValues { 5 | High, 6 | Low, 7 | NextTo, 8 | None, 9 | } 10 | impl Default for TickLabelPositionValues { 11 | fn default() -> Self { 12 | Self::High 13 | } 14 | } 15 | impl EnumTrait for TickLabelPositionValues { 16 | fn get_value_string(&self) -> &str { 17 | match &self { 18 | Self::High => "high", 19 | Self::Low => "low", 20 | Self::NextTo => "nextTo", 21 | Self::None => "none", 22 | } 23 | } 24 | } 25 | impl FromStr for TickLabelPositionValues { 26 | type Err = (); 27 | fn from_str(input: &str) -> Result { 28 | match input { 29 | "high" => Ok(Self::High), 30 | "low" => Ok(Self::Low), 31 | "nextTo" => Ok(Self::NextTo), 32 | "none" => Ok(Self::None), 33 | _ => Err(()), 34 | } 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/tick_mark_values.rs: -------------------------------------------------------------------------------- 1 | use super::super::super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug, Default)] 4 | pub enum TickMarkValues { 5 | #[default] 6 | Cross, 7 | Inside, 8 | None, 9 | Outside, 10 | } 11 | 12 | impl EnumTrait for TickMarkValues { 13 | fn get_value_string(&self) -> &str { 14 | match &self { 15 | Self::Cross => "cross", 16 | Self::Inside => "in", 17 | Self::None => "none", 18 | Self::Outside => "out", 19 | } 20 | } 21 | } 22 | impl FromStr for TickMarkValues { 23 | type Err = (); 24 | fn from_str(input: &str) -> Result { 25 | match input { 26 | "cross" => Ok(Self::Cross), 27 | "in" => Ok(Self::Inside), 28 | "none" => Ok(Self::None), 29 | "out" => Ok(Self::Outside), 30 | _ => Err(()), 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/time_unit_values.rs: -------------------------------------------------------------------------------- 1 | use super::super::super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug)] 4 | pub enum TimeUnitValues { 5 | Days, 6 | Months, 7 | Years, 8 | } 9 | impl Default for TimeUnitValues { 10 | fn default() -> Self { 11 | Self::Days 12 | } 13 | } 14 | impl EnumTrait for TimeUnitValues { 15 | fn get_value_string(&self) -> &str { 16 | match &self { 17 | Self::Days => "days", 18 | Self::Months => "months", 19 | Self::Years => "years", 20 | } 21 | } 22 | } 23 | impl FromStr for TimeUnitValues { 24 | type Err = (); 25 | fn from_str(input: &str) -> Result { 26 | match input { 27 | "days" => Ok(Self::Days), 28 | "months" => Ok(Self::Months), 29 | "years" => Ok(Self::Years), 30 | _ => Err(()), 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/top.rs: -------------------------------------------------------------------------------- 1 | // c:y 2 | use super::super::super::DoubleValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct Top { 12 | val: DoubleValue, 13 | } 14 | impl Top { 15 | pub fn get_val(&self) -> &f64 { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: f64) -> &mut Top { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:y 34 | write_start_tag( 35 | writer, 36 | "c:y", 37 | vec![("val", &self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/top_mode.rs: -------------------------------------------------------------------------------- 1 | // c:yMode 2 | use super::super::super::EnumValue; 3 | use super::LayoutModeValues; 4 | use crate::reader::driver::*; 5 | use crate::writer::driver::*; 6 | use quick_xml::events::BytesStart; 7 | use quick_xml::Reader; 8 | use quick_xml::Writer; 9 | use std::io::Cursor; 10 | 11 | #[derive(Clone, Default, Debug)] 12 | pub struct TopMode { 13 | val: EnumValue, 14 | } 15 | impl TopMode { 16 | pub fn get_val(&self) -> &LayoutModeValues { 17 | self.val.get_value() 18 | } 19 | 20 | pub fn set_val(&mut self, value: LayoutModeValues) -> &mut TopMode { 21 | self.val.set_value(value); 22 | self 23 | } 24 | 25 | pub(crate) fn set_attributes( 26 | &mut self, 27 | _reader: &mut Reader, 28 | e: &BytesStart, 29 | ) { 30 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 31 | } 32 | 33 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 34 | // c:yMode 35 | write_start_tag( 36 | writer, 37 | "c:yMode", 38 | vec![("val", self.val.get_value_string())], 39 | true, 40 | ); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/vary_colors.rs: -------------------------------------------------------------------------------- 1 | // c:varyColors 2 | use super::super::super::BooleanValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct VaryColors { 12 | val: BooleanValue, 13 | } 14 | impl VaryColors { 15 | pub fn get_val(&self) -> &bool { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: bool) -> &mut VaryColors { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:varyColors 34 | write_start_tag( 35 | writer, 36 | "c:varyColors", 37 | vec![("val", self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/width.rs: -------------------------------------------------------------------------------- 1 | // c:w 2 | use super::super::super::DoubleValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct Width { 12 | val: DoubleValue, 13 | } 14 | impl Width { 15 | pub fn get_val(&self) -> &f64 { 16 | self.val.get_value() 17 | } 18 | 19 | pub fn set_val(&mut self, value: f64) -> &mut Width { 20 | self.val.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // c:w 34 | write_start_tag( 35 | writer, 36 | "c:w", 37 | vec![("val", &self.val.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/drawing/charts/width_mode.rs: -------------------------------------------------------------------------------- 1 | // c:wMode 2 | use super::super::super::EnumValue; 3 | use super::LayoutModeValues; 4 | use crate::reader::driver::*; 5 | use crate::writer::driver::*; 6 | use quick_xml::events::BytesStart; 7 | use quick_xml::Reader; 8 | use quick_xml::Writer; 9 | use std::io::Cursor; 10 | 11 | #[derive(Clone, Default, Debug)] 12 | pub struct WidthMode { 13 | val: EnumValue, 14 | } 15 | impl WidthMode { 16 | pub fn get_val(&self) -> &LayoutModeValues { 17 | self.val.get_value() 18 | } 19 | 20 | pub fn set_val(&mut self, value: LayoutModeValues) -> &mut WidthMode { 21 | self.val.set_value(value); 22 | self 23 | } 24 | 25 | pub(crate) fn set_attributes( 26 | &mut self, 27 | _reader: &mut Reader, 28 | e: &BytesStart, 29 | ) { 30 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 31 | } 32 | 33 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 34 | // c:wMode 35 | write_start_tag( 36 | writer, 37 | "c:wMode", 38 | vec![("val", self.val.get_value_string())], 39 | true, 40 | ); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/structs/drawing/extension_list.rs: -------------------------------------------------------------------------------- 1 | // a:extLst 2 | use crate::reader::driver::*; 3 | use crate::writer::driver::*; 4 | use quick_xml::events::BytesStart; 5 | use quick_xml::events::Event; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct ExtensionList {} 12 | impl ExtensionList { 13 | #[inline] 14 | pub(crate) fn set_attributes( 15 | &mut self, 16 | reader: &mut Reader, 17 | _e: &BytesStart, 18 | ) { 19 | xml_read_loop!( 20 | reader, 21 | Event::End(ref e) => { 22 | if e.name().into_inner() == b"a:extLst" { 23 | return 24 | } 25 | }, 26 | Event::Eof => panic!("Error: Could not find {} end element", "a:extLst") 27 | ); 28 | } 29 | 30 | #[inline] 31 | pub(crate) fn write_to(&self, writer: &mut Writer>>) {} 32 | } 33 | -------------------------------------------------------------------------------- /src/structs/drawing/miter.rs: -------------------------------------------------------------------------------- 1 | // a:miter 2 | use crate::reader::driver::*; 3 | use crate::writer::driver::*; 4 | use crate::Int32Value; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct Miter { 12 | limit: Int32Value, 13 | } 14 | 15 | impl Miter { 16 | #[inline] 17 | pub fn get_limit(&self) -> &i32 { 18 | self.limit.get_value() 19 | } 20 | 21 | #[inline] 22 | pub fn set_limit(&mut self, value: i32) -> &mut Self { 23 | self.limit.set_value(value); 24 | self 25 | } 26 | 27 | #[inline] 28 | pub(crate) fn set_attributes( 29 | &mut self, 30 | _reader: &mut Reader, 31 | e: &BytesStart, 32 | ) { 33 | set_string_from_xml!(self, e, limit, "lim"); 34 | } 35 | 36 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 37 | // a:miter 38 | let mut attributes: Vec<(&str, &str)> = Vec::new(); 39 | let lim = self.limit.get_value_string(); 40 | if self.limit.has_value() { 41 | attributes.push(("lim", &lim)); 42 | } 43 | write_start_tag(writer, "a:miter", attributes, true); 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /src/structs/drawing/no_fill.rs: -------------------------------------------------------------------------------- 1 | // a:noFill 2 | use crate::writer::driver::*; 3 | use quick_xml::events::BytesStart; 4 | use quick_xml::Reader; 5 | use quick_xml::Writer; 6 | use std::io::Cursor; 7 | 8 | #[derive(Clone, Default, Debug)] 9 | pub struct NoFill {} 10 | impl NoFill { 11 | #[inline] 12 | pub(crate) fn set_attributes( 13 | &mut self, 14 | _reader: &mut Reader, 15 | _: &BytesStart, 16 | ) { 17 | } 18 | 19 | #[inline] 20 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 21 | // a:noFill 22 | write_start_tag(writer, "a:noFill", vec![], true); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/structs/drawing/pen_alignment_values.rs: -------------------------------------------------------------------------------- 1 | use super::super::super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug)] 4 | pub enum PenAlignmentValues { 5 | Center, 6 | Insert, 7 | } 8 | impl Default for PenAlignmentValues { 9 | #[inline] 10 | fn default() -> Self { 11 | Self::Center 12 | } 13 | } 14 | impl EnumTrait for PenAlignmentValues { 15 | #[inline] 16 | fn get_value_string(&self) -> &str { 17 | match &self { 18 | Self::Center => "ctr", 19 | Self::Insert => "in", 20 | } 21 | } 22 | } 23 | impl FromStr for PenAlignmentValues { 24 | type Err = (); 25 | 26 | #[inline] 27 | fn from_str(input: &str) -> Result { 28 | match input { 29 | "ctr" => Ok(Self::Center), 30 | "in" => Ok(Self::Insert), 31 | _ => Err(()), 32 | } 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /src/structs/drawing/pictures.rs: -------------------------------------------------------------------------------- 1 | pub mod blip_fill; 2 | pub mod non_visual_drawing_properties; 3 | pub mod non_visual_picture_drawing_properties; 4 | pub mod non_visual_picture_properties; 5 | pub mod picture; 6 | pub mod shape_properties; 7 | 8 | -------------------------------------------------------------------------------- /src/structs/drawing/preset_dash.rs: -------------------------------------------------------------------------------- 1 | // a:prstDash 2 | use super::super::EnumValue; 3 | use super::PresetLineDashValues; 4 | use crate::reader::driver::*; 5 | use crate::writer::driver::*; 6 | use quick_xml::events::BytesStart; 7 | use quick_xml::Reader; 8 | use quick_xml::Writer; 9 | use std::io::Cursor; 10 | 11 | #[derive(Clone, Default, Debug)] 12 | pub struct PresetDash { 13 | val: EnumValue, 14 | } 15 | impl PresetDash { 16 | #[inline] 17 | pub fn get_val(&self) -> &PresetLineDashValues { 18 | self.val.get_value() 19 | } 20 | 21 | #[inline] 22 | pub fn set_val(&mut self, value: PresetLineDashValues) -> &mut PresetDash { 23 | self.val.set_value(value); 24 | self 25 | } 26 | 27 | #[inline] 28 | pub(crate) fn set_attributes( 29 | &mut self, 30 | _reader: &mut Reader, 31 | e: &BytesStart, 32 | ) { 33 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 34 | } 35 | 36 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 37 | // a:prstDash 38 | write_start_tag( 39 | writer, 40 | "a:prstDash", 41 | vec![("val", self.val.get_value_string())], 42 | true, 43 | ); 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /src/structs/drawing/round.rs: -------------------------------------------------------------------------------- 1 | // a:round 2 | use crate::writer::driver::*; 3 | use quick_xml::events::BytesStart; 4 | use quick_xml::Reader; 5 | use quick_xml::Writer; 6 | use std::io::Cursor; 7 | 8 | #[derive(Clone, Default, Debug)] 9 | pub struct Round {} 10 | impl Round { 11 | #[inline] 12 | pub(crate) fn set_attributes( 13 | &mut self, 14 | _reader: &mut Reader, 15 | _e: &BytesStart, 16 | ) { 17 | } 18 | 19 | #[inline] 20 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 21 | // a:round 22 | write_start_tag(writer, "a:round", vec![], true); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/structs/drawing/shape_auto_fit.rs: -------------------------------------------------------------------------------- 1 | // a:spAutoFit 2 | use crate::writer::driver::*; 3 | use quick_xml::events::BytesStart; 4 | use quick_xml::Reader; 5 | use quick_xml::Writer; 6 | use std::io::Cursor; 7 | 8 | #[derive(Clone, Default, Debug)] 9 | pub struct ShapeAutoFit {} 10 | impl ShapeAutoFit { 11 | #[inline] 12 | pub(crate) fn set_attributes( 13 | &mut self, 14 | _reader: &mut Reader, 15 | _: &BytesStart, 16 | ) { 17 | } 18 | 19 | #[inline] 20 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 21 | // a:spAutoFit 22 | write_start_tag(writer, "a:spAutoFit", vec![], true); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/structs/drawing/shape_guide.rs: -------------------------------------------------------------------------------- 1 | // a:gd 2 | use crate::writer::driver::*; 3 | use quick_xml::Writer; 4 | use std::io::Cursor; 5 | 6 | #[derive(Clone, Default, Debug)] 7 | pub struct ShapeGuide { 8 | name: Box, 9 | fmla: Box, 10 | } 11 | impl ShapeGuide { 12 | #[inline] 13 | pub fn get_name(&self) -> &str { 14 | &self.name 15 | } 16 | 17 | #[inline] 18 | pub fn set_name>(&mut self, value: S) { 19 | self.name = value.into().into_boxed_str(); 20 | } 21 | 22 | #[inline] 23 | pub fn get_fmla(&self) -> &str { 24 | &self.fmla 25 | } 26 | 27 | #[inline] 28 | pub fn set_fmla>(&mut self, value: S) { 29 | self.fmla = value.into().into_boxed_str(); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | write_start_tag( 34 | writer, 35 | "a:gd", 36 | vec![("name", &self.name), ("fmla", &self.fmla)], 37 | true, 38 | ); 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/structs/drawing/soft_edge.rs: -------------------------------------------------------------------------------- 1 | // a:softEdge 2 | use super::super::super::Int64Value; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct SoftEdge { 12 | radius: Int64Value, 13 | } 14 | impl SoftEdge { 15 | #[inline] 16 | pub fn get_radius(&self) -> &i64 { 17 | self.radius.get_value() 18 | } 19 | 20 | #[inline] 21 | pub fn set_radius(&mut self, value: i64) -> &mut SoftEdge { 22 | self.radius.set_value(value); 23 | self 24 | } 25 | 26 | #[inline] 27 | pub(crate) fn set_attributes( 28 | &mut self, 29 | _reader: &mut Reader, 30 | e: &BytesStart, 31 | ) { 32 | self.radius 33 | .set_value_string(get_attribute(e, b"rad").unwrap()); 34 | } 35 | 36 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 37 | // a:softEdge 38 | write_start_tag( 39 | writer, 40 | "a:softEdge", 41 | vec![("rad", &self.radius.get_value_string())], 42 | true, 43 | ); 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /src/structs/drawing/spacing_percent.rs: -------------------------------------------------------------------------------- 1 | // a:spcPct 2 | use super::super::super::Int32Value; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct SpacingPercent { 12 | val: Int32Value, 13 | } 14 | impl SpacingPercent { 15 | #[inline] 16 | pub fn get_val(&self) -> &i32 { 17 | self.val.get_value() 18 | } 19 | 20 | #[inline] 21 | pub fn set_val(&mut self, value: i32) -> &mut Self { 22 | self.val.set_value(value); 23 | self 24 | } 25 | 26 | #[inline] 27 | pub(crate) fn set_attributes( 28 | &mut self, 29 | _reader: &mut Reader, 30 | e: &BytesStart, 31 | ) { 32 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 33 | } 34 | 35 | #[inline] 36 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 37 | // a:spcPct 38 | write_start_tag( 39 | writer, 40 | "a:spcPct", 41 | vec![("val", &self.val.get_value_string())], 42 | true, 43 | ); 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /src/structs/drawing/spreadsheet/edit_as_values.rs: -------------------------------------------------------------------------------- 1 | use super::super::super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug)] 4 | pub enum EditAsValues { 5 | Absolute, 6 | OneCell, 7 | TwoCell, 8 | } 9 | impl Default for EditAsValues { 10 | #[inline] 11 | fn default() -> Self { 12 | Self::TwoCell 13 | } 14 | } 15 | impl EnumTrait for EditAsValues { 16 | #[inline] 17 | fn get_value_string(&self) -> &str { 18 | match &self { 19 | Self::Absolute => "absolute", 20 | Self::OneCell => "oneCell", 21 | Self::TwoCell => "twoCell", 22 | } 23 | } 24 | } 25 | impl FromStr for EditAsValues { 26 | type Err = (); 27 | 28 | #[inline] 29 | fn from_str(input: &str) -> Result { 30 | match input { 31 | "absolute" => Ok(Self::Absolute), 32 | "oneCell" => Ok(Self::OneCell), 33 | "twoCell" => Ok(Self::TwoCell), 34 | _ => Err(()), 35 | } 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /src/structs/drawing/spreadsheet/non_visual_graphic_frame_drawing_properties.rs: -------------------------------------------------------------------------------- 1 | // xdr:cNvGraphicFramePr 2 | use crate::writer::driver::*; 3 | use quick_xml::events::BytesStart; 4 | use quick_xml::Reader; 5 | use quick_xml::Writer; 6 | use std::io::Cursor; 7 | 8 | #[derive(Clone, Default, Debug)] 9 | pub struct NonVisualGraphicFrameDrawingProperties {} 10 | impl NonVisualGraphicFrameDrawingProperties { 11 | #[inline] 12 | pub(crate) fn set_attributes( 13 | &mut self, 14 | _reader: &mut Reader, 15 | _e: &BytesStart, 16 | ) { 17 | } 18 | 19 | #[inline] 20 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 21 | // xdr:cNvGraphicFramePr 22 | write_start_tag(writer, "xdr:cNvGraphicFramePr", vec![], true); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/structs/drawing/text_caps_values.rs: -------------------------------------------------------------------------------- 1 | use super::super::super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug)] 4 | pub enum TextCapsValues { 5 | All, 6 | None, 7 | Small, 8 | } 9 | impl Default for TextCapsValues { 10 | #[inline] 11 | fn default() -> Self { 12 | Self::None 13 | } 14 | } 15 | impl EnumTrait for TextCapsValues { 16 | #[inline] 17 | fn get_value_string(&self) -> &str { 18 | match &self { 19 | Self::All => "all", 20 | Self::None => "none", 21 | Self::Small => "small", 22 | } 23 | } 24 | } 25 | impl FromStr for TextCapsValues { 26 | type Err = (); 27 | 28 | #[inline] 29 | fn from_str(input: &str) -> Result { 30 | match input { 31 | "all" => Ok(Self::All), 32 | "none" => Ok(Self::None), 33 | "small" => Ok(Self::Small), 34 | _ => Err(()), 35 | } 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /src/structs/drawing/text_font_alignment_values.rs: -------------------------------------------------------------------------------- 1 | use super::super::super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug)] 4 | pub enum TextFontAlignmentValues { 5 | Automatic, 6 | Baseline, 7 | Bottom, 8 | Center, 9 | Top, 10 | } 11 | impl Default for TextFontAlignmentValues { 12 | #[inline] 13 | fn default() -> Self { 14 | Self::Automatic 15 | } 16 | } 17 | impl EnumTrait for TextFontAlignmentValues { 18 | #[inline] 19 | fn get_value_string(&self) -> &str { 20 | match &self { 21 | Self::Automatic => "auto", 22 | Self::Baseline => "base", 23 | Self::Bottom => "b", 24 | Self::Center => "ctr", 25 | Self::Top => "t", 26 | } 27 | } 28 | } 29 | impl FromStr for TextFontAlignmentValues { 30 | type Err = (); 31 | 32 | #[inline] 33 | fn from_str(input: &str) -> Result { 34 | match input { 35 | "auto" => Ok(Self::Automatic), 36 | "base" => Ok(Self::Baseline), 37 | "b" => Ok(Self::Bottom), 38 | "ctr" => Ok(Self::Center), 39 | "t" => Ok(Self::Top), 40 | _ => Err(()), 41 | } 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /src/structs/drawing/text_wrapping_values.rs: -------------------------------------------------------------------------------- 1 | use super::super::super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug)] 4 | pub enum TextWrappingValues { 5 | None, 6 | Square, 7 | } 8 | impl Default for TextWrappingValues { 9 | #[inline] 10 | fn default() -> Self { 11 | Self::None 12 | } 13 | } 14 | impl EnumTrait for TextWrappingValues { 15 | #[inline] 16 | fn get_value_string(&self) -> &str { 17 | match &self { 18 | Self::None => "none", 19 | Self::Square => "square", 20 | } 21 | } 22 | } 23 | impl FromStr for TextWrappingValues { 24 | type Err = (); 25 | 26 | #[inline] 27 | fn from_str(input: &str) -> Result { 28 | match input { 29 | "none" => Ok(Self::None), 30 | "square" => Ok(Self::Square), 31 | _ => Err(()), 32 | } 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /src/structs/drawing/tile_flip_values.rs: -------------------------------------------------------------------------------- 1 | use super::super::super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug)] 4 | pub enum TileFlipValues { 5 | Horizontal, 6 | HorizontalAndVertical, 7 | None, 8 | Vertical, 9 | } 10 | impl Default for TileFlipValues { 11 | #[inline] 12 | fn default() -> Self { 13 | Self::None 14 | } 15 | } 16 | impl EnumTrait for TileFlipValues { 17 | #[inline] 18 | fn get_value_string(&self) -> &str { 19 | match &self { 20 | Self::Horizontal => "x", 21 | Self::HorizontalAndVertical => "xy", 22 | Self::None => "none", 23 | Self::Vertical => "y", 24 | } 25 | } 26 | } 27 | impl FromStr for TileFlipValues { 28 | type Err = (); 29 | 30 | #[inline] 31 | fn from_str(input: &str) -> Result { 32 | match input { 33 | "x" => Ok(Self::Horizontal), 34 | "xy" => Ok(Self::HorizontalAndVertical), 35 | "none" => Ok(Self::None), 36 | "y" => Ok(Self::Vertical), 37 | _ => Err(()), 38 | } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/structs/drawing/tile_rectangle.rs: -------------------------------------------------------------------------------- 1 | // a:tileRect 2 | use crate::writer::driver::*; 3 | use quick_xml::events::BytesStart; 4 | use quick_xml::Reader; 5 | use quick_xml::Writer; 6 | use std::io::Cursor; 7 | 8 | #[derive(Clone, Default, Debug)] 9 | pub struct TileRectangle {} 10 | impl TileRectangle { 11 | #[inline] 12 | pub(crate) fn set_attributes( 13 | &mut self, 14 | _reader: &mut Reader, 15 | _e: &BytesStart, 16 | ) { 17 | } 18 | 19 | #[inline] 20 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 21 | // a:tileRect 22 | write_start_tag(writer, "a:tileRect", vec![], true); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/structs/enum_trait.rs: -------------------------------------------------------------------------------- 1 | pub trait EnumTrait { 2 | fn get_value_string(&self) -> &str; 3 | } 4 | -------------------------------------------------------------------------------- /src/structs/field.rs: -------------------------------------------------------------------------------- 1 | // field 2 | use crate::reader::driver::*; 3 | use crate::structs::Int32Value; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::{BytesStart, Event}; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug)] 11 | pub struct Field { 12 | x: Int32Value, 13 | } 14 | impl Field { 15 | pub fn get_data_field(&self) -> &i32 { 16 | self.x.get_value() 17 | } 18 | 19 | pub fn set_data_field(&mut self, value: i32) -> &mut Self { 20 | self.x.set_value(value); 21 | self 22 | } 23 | 24 | pub(crate) fn set_attributes( 25 | &mut self, 26 | _reader: &mut Reader, 27 | e: &BytesStart, 28 | ) { 29 | set_string_from_xml!(self, e, x, "x"); 30 | } 31 | 32 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 33 | // pivotField 34 | write_start_tag( 35 | writer, 36 | "field", 37 | vec![("x", &self.x.get_value_string())], 38 | true, 39 | ); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/font_scheme_values.rs: -------------------------------------------------------------------------------- 1 | use super::EnumTrait; 2 | use std::str::FromStr; 3 | 4 | #[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)] 5 | pub enum FontSchemeValues { 6 | Major, 7 | Minor, 8 | None, 9 | } 10 | 11 | impl Default for FontSchemeValues { 12 | #[inline] 13 | fn default() -> Self { 14 | Self::None 15 | } 16 | } 17 | 18 | impl EnumTrait for FontSchemeValues { 19 | #[inline] 20 | fn get_value_string(&self) -> &str { 21 | match &self { 22 | Self::Major => "major", 23 | Self::Minor => "minor", 24 | Self::None => "none", 25 | } 26 | } 27 | } 28 | 29 | impl FromStr for FontSchemeValues { 30 | type Err = (); 31 | 32 | #[inline] 33 | fn from_str(input: &str) -> Result { 34 | match input { 35 | "major" => Ok(Self::Major), 36 | "minor" => Ok(Self::Minor), 37 | "none" => Ok(Self::None), 38 | _ => Err(()), 39 | } 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/structs/font_size.rs: -------------------------------------------------------------------------------- 1 | // sz 2 | use super::DoubleValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug, PartialEq, PartialOrd)] 11 | pub struct FontSize { 12 | pub(crate) val: DoubleValue, 13 | } 14 | 15 | impl FontSize { 16 | #[inline] 17 | pub fn get_val(&self) -> &f64 { 18 | self.val.get_value() 19 | } 20 | 21 | #[inline] 22 | pub fn set_val(&mut self, value: f64) -> &mut Self { 23 | self.val.set_value(value); 24 | self 25 | } 26 | 27 | #[inline] 28 | pub(crate) fn set_attributes( 29 | &mut self, 30 | _reader: &mut Reader, 31 | e: &BytesStart, 32 | ) { 33 | self.val.set_value_string(get_attribute(e, b"val").unwrap()); 34 | } 35 | 36 | #[inline] 37 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 38 | // sz 39 | if self.val.has_value() { 40 | write_start_tag( 41 | writer, 42 | "sz", 43 | vec![("val", &self.val.get_value_string())], 44 | true, 45 | ); 46 | } 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /src/structs/hyperlink.rs: -------------------------------------------------------------------------------- 1 | #[derive(Clone, Default, Debug, Eq, Ord, PartialEq, PartialOrd)] 2 | pub struct Hyperlink { 3 | url: Box, 4 | tooltip: Box, 5 | location: bool, 6 | } 7 | impl Hyperlink { 8 | #[inline] 9 | pub fn get_url(&self) -> &str { 10 | &self.url 11 | } 12 | 13 | #[inline] 14 | pub fn set_url>(&mut self, value: S) -> &mut Hyperlink { 15 | self.url = value.into().into_boxed_str(); 16 | self 17 | } 18 | 19 | #[inline] 20 | pub fn get_tooltip(&self) -> &str { 21 | &self.tooltip 22 | } 23 | 24 | #[inline] 25 | pub fn set_tooltip>(&mut self, value: S) -> &mut Hyperlink { 26 | self.tooltip = value.into().into_boxed_str(); 27 | self 28 | } 29 | 30 | #[inline] 31 | pub fn get_location(&self) -> &bool { 32 | &self.location 33 | } 34 | 35 | #[inline] 36 | pub fn set_location(&mut self, value: bool) -> &mut Hyperlink { 37 | self.location = value; 38 | self 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/structs/int16_value.rs: -------------------------------------------------------------------------------- 1 | #[derive(Clone, Default, Debug)] 2 | pub struct Int16Value { 3 | #[allow(dead_code)] 4 | value: Option, 5 | } 6 | impl Int16Value { 7 | #[inline] 8 | pub(crate) fn _get_value(&self) -> &i16 { 9 | match &self.value { 10 | Some(v) => v, 11 | None => &0, 12 | } 13 | } 14 | 15 | #[inline] 16 | pub(crate) fn _get_value_string(&self) -> String { 17 | self._get_value().to_string() 18 | } 19 | 20 | #[inline] 21 | pub(crate) fn _set_value(&mut self, value: i16) -> &mut Int16Value { 22 | self.value = Some(value); 23 | self 24 | } 25 | 26 | #[inline] 27 | pub(crate) fn _set_value_string>(&mut self, value: S) -> &mut Int16Value { 28 | self._set_value(value.into().parse::().unwrap()) 29 | } 30 | 31 | #[inline] 32 | pub(crate) fn _has_value(&self) -> bool { 33 | self.value.is_some() 34 | } 35 | 36 | #[inline] 37 | pub(crate) fn _get_hash_string(&self) -> String { 38 | if self._has_value() { 39 | return self._get_value_string(); 40 | } 41 | String::from("empty!!") 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /src/structs/int32_value.rs: -------------------------------------------------------------------------------- 1 | #[derive(Clone, Default, Debug, Eq, Ord, PartialEq, PartialOrd)] 2 | pub struct Int32Value { 3 | value: Option, 4 | } 5 | impl Int32Value { 6 | #[inline] 7 | pub(crate) fn get_value(&self) -> &i32 { 8 | match &self.value { 9 | Some(v) => v, 10 | None => &0, 11 | } 12 | } 13 | 14 | #[inline] 15 | pub(crate) fn get_value_string(&self) -> String { 16 | self.get_value().to_string() 17 | } 18 | 19 | #[inline] 20 | pub(crate) fn set_value(&mut self, value: i32) -> &mut Self { 21 | self.value = Some(value); 22 | self 23 | } 24 | 25 | #[inline] 26 | pub(crate) fn set_value_string>(&mut self, value: S) -> &mut Self { 27 | self.set_value(value.into().parse::().unwrap()) 28 | } 29 | 30 | #[inline] 31 | pub(crate) fn has_value(&self) -> bool { 32 | self.value.is_some() 33 | } 34 | 35 | #[inline] 36 | pub(crate) fn get_hash_string(&self) -> String { 37 | if self.has_value() { 38 | return self.get_value_string(); 39 | } 40 | String::from("empty!!") 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/structs/int64_value.rs: -------------------------------------------------------------------------------- 1 | #[derive(Clone, Default, Debug)] 2 | pub struct Int64Value { 3 | value: Option, 4 | } 5 | impl Int64Value { 6 | #[inline] 7 | pub(crate) fn get_value(&self) -> &i64 { 8 | match &self.value { 9 | Some(v) => v, 10 | None => &0, 11 | } 12 | } 13 | 14 | #[inline] 15 | pub(crate) fn get_value_string(&self) -> String { 16 | self.get_value().to_string() 17 | } 18 | 19 | #[inline] 20 | pub(crate) fn set_value(&mut self, value: i64) -> &mut Int64Value { 21 | self.value = Some(value); 22 | self 23 | } 24 | 25 | #[inline] 26 | pub(crate) fn set_value_string>(&mut self, value: S) -> &mut Int64Value { 27 | self.set_value(value.into().parse::().unwrap()) 28 | } 29 | 30 | #[inline] 31 | pub(crate) fn has_value(&self) -> bool { 32 | self.value.is_some() 33 | } 34 | 35 | #[inline] 36 | pub(crate) fn _get_hash_string(&self) -> String { 37 | if self.has_value() { 38 | return self.get_value_string(); 39 | } 40 | String::from("empty!!") 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/structs/italic.rs: -------------------------------------------------------------------------------- 1 | // i 2 | use super::BooleanValue; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug, Eq, Ord, PartialEq, PartialOrd)] 11 | pub struct Italic { 12 | pub(crate) val: BooleanValue, 13 | } 14 | 15 | impl Italic { 16 | #[inline] 17 | pub fn get_val(&self) -> &bool { 18 | self.val.get_value() 19 | } 20 | 21 | #[inline] 22 | pub fn set_val(&mut self, value: bool) -> &mut Self { 23 | self.val.set_value(value); 24 | self 25 | } 26 | 27 | #[inline] 28 | pub(crate) fn set_attributes( 29 | &mut self, 30 | _reader: &mut Reader, 31 | e: &BytesStart, 32 | ) { 33 | self.val.set_value(true); 34 | set_string_from_xml!(self, e, val, "val"); 35 | } 36 | 37 | #[inline] 38 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 39 | // i 40 | if *self.val.get_value() { 41 | write_start_tag(writer, "i", vec![], true); 42 | } 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /src/structs/member_property_index.rs: -------------------------------------------------------------------------------- 1 | // x 2 | use super::Int32Value; 3 | use crate::reader::driver::*; 4 | use crate::writer::driver::*; 5 | use quick_xml::events::BytesStart; 6 | use quick_xml::Reader; 7 | use quick_xml::Writer; 8 | use std::io::Cursor; 9 | 10 | #[derive(Clone, Default, Debug, Eq, Ord, PartialEq, PartialOrd)] 11 | pub struct MemberPropertyIndex { 12 | pub(crate) val: Int32Value, 13 | } 14 | 15 | impl MemberPropertyIndex { 16 | pub fn get_val(&self) -> &i32 { 17 | self.val.get_value() 18 | } 19 | 20 | pub fn set_val(&mut self, value: i32) -> &mut Self { 21 | self.val.set_value(value); 22 | self 23 | } 24 | 25 | pub(crate) fn set_attributes( 26 | &mut self, 27 | _reader: &mut Reader, 28 | e: &BytesStart, 29 | ) { 30 | set_string_from_xml!(self, e, val, "val"); 31 | } 32 | 33 | pub(crate) fn write_to(&self, writer: &mut Writer>>) { 34 | // x 35 | if self.val.has_value() { 36 | let mut attributes: Vec<(&str, &str)> = Vec::new(); 37 | let val = self.val.get_value_string(); 38 | attributes.push(("val", &val)); 39 | write_start_tag(writer, "x", attributes, true); 40 | } 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/structs/office.rs: -------------------------------------------------------------------------------- 1 | pub mod excel; 2 | -------------------------------------------------------------------------------- /src/structs/office/excel.rs: -------------------------------------------------------------------------------- 1 | mod formula; 2 | pub use self::formula::*; 3 | 4 | mod reference_sequence; 5 | pub use self::reference_sequence::*; 6 | -------------------------------------------------------------------------------- /src/structs/office2010.rs: -------------------------------------------------------------------------------- 1 | pub mod drawing; 2 | pub mod excel; 3 | -------------------------------------------------------------------------------- /src/structs/office2010/drawing.rs: -------------------------------------------------------------------------------- 1 | pub mod charts; 2 | -------------------------------------------------------------------------------- /src/structs/office2010/drawing/charts.rs: -------------------------------------------------------------------------------- 1 | mod style; 2 | pub use self::style::*; 3 | -------------------------------------------------------------------------------- /src/structs/office2010/excel.rs: -------------------------------------------------------------------------------- 1 | mod data_validation; 2 | pub use self::data_validation::*; 3 | 4 | mod data_validations; 5 | pub use self::data_validations::*; 6 | 7 | mod data_validation_forumla1; 8 | pub use self::data_validation_forumla1::*; 9 | 10 | mod data_validation_forumla2; 11 | pub use self::data_validation_forumla2::*; 12 | -------------------------------------------------------------------------------- /src/structs/orientation_values.rs: -------------------------------------------------------------------------------- 1 | use super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug)] 4 | pub enum OrientationValues { 5 | Default, 6 | Landscape, 7 | Portrait, 8 | } 9 | impl Default for OrientationValues { 10 | #[inline] 11 | fn default() -> Self { 12 | Self::Default 13 | } 14 | } 15 | impl EnumTrait for OrientationValues { 16 | #[inline] 17 | fn get_value_string(&self) -> &str { 18 | match &self { 19 | Self::Default => "default", 20 | Self::Landscape => "landscape", 21 | Self::Portrait => "portrait", 22 | } 23 | } 24 | } 25 | impl FromStr for OrientationValues { 26 | type Err = (); 27 | 28 | #[inline] 29 | fn from_str(input: &str) -> Result { 30 | match input { 31 | "default" => Ok(Self::Default), 32 | "landscape" => Ok(Self::Landscape), 33 | "portrait" => Ok(Self::Portrait), 34 | _ => Err(()), 35 | } 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /src/structs/pane_state_values.rs: -------------------------------------------------------------------------------- 1 | use super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug)] 4 | pub enum PaneStateValues { 5 | Frozen, 6 | FrozenSplit, 7 | Split, 8 | } 9 | impl Default for PaneStateValues { 10 | #[inline] 11 | fn default() -> Self { 12 | Self::Split 13 | } 14 | } 15 | impl EnumTrait for PaneStateValues { 16 | #[inline] 17 | fn get_value_string(&self) -> &str { 18 | match &self { 19 | Self::Frozen => "frozen", 20 | Self::FrozenSplit => "frozenSplit", 21 | Self::Split => "split", 22 | } 23 | } 24 | } 25 | impl FromStr for PaneStateValues { 26 | type Err = (); 27 | 28 | #[inline] 29 | fn from_str(input: &str) -> Result { 30 | match input { 31 | "frozen" => Ok(Self::Frozen), 32 | "frozenSplit" => Ok(Self::FrozenSplit), 33 | "split" => Ok(Self::Split), 34 | _ => Err(()), 35 | } 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /src/structs/pane_values.rs: -------------------------------------------------------------------------------- 1 | use super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug)] 4 | pub enum PaneValues { 5 | BottomLeft, 6 | BottomRight, 7 | TopLeft, 8 | TopRight, 9 | } 10 | impl Default for PaneValues { 11 | #[inline] 12 | fn default() -> Self { 13 | Self::BottomRight 14 | } 15 | } 16 | impl EnumTrait for PaneValues { 17 | #[inline] 18 | fn get_value_string(&self) -> &str { 19 | match &self { 20 | Self::BottomLeft => "bottomLeft", 21 | Self::BottomRight => "bottomRight", 22 | Self::TopLeft => "topLeft", 23 | Self::TopRight => "TopRight", 24 | } 25 | } 26 | } 27 | impl FromStr for PaneValues { 28 | type Err = (); 29 | 30 | #[inline] 31 | fn from_str(input: &str) -> Result { 32 | match input { 33 | "bottomLeft" => Ok(Self::BottomLeft), 34 | "bottomRight" => Ok(Self::BottomRight), 35 | "topLeft" => Ok(Self::TopLeft), 36 | "TopRight" => Ok(Self::TopRight), 37 | _ => Err(()), 38 | } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/structs/phonetic_run.rs: -------------------------------------------------------------------------------- 1 | // si 2 | use crate::reader::driver::*; 3 | use quick_xml::events::{BytesStart, Event}; 4 | use quick_xml::Reader; 5 | use quick_xml::Writer; 6 | use std::io::Cursor; 7 | 8 | #[derive(Default, Debug)] 9 | pub(crate) struct PhoneticRun {} 10 | 11 | impl PhoneticRun { 12 | pub(crate) fn set_attributes( 13 | &mut self, 14 | reader: &mut Reader, 15 | _e: &BytesStart, 16 | ) { 17 | xml_read_loop!( 18 | reader, 19 | Event::End(ref e) => { 20 | if e.name().into_inner() == b"rPh" { 21 | return 22 | } 23 | }, 24 | Event::Eof => panic!("Error: Could not find {} end element", "rPh") 25 | ); 26 | } 27 | 28 | pub(crate) fn _write_to(&self, _writer: &mut Writer>>) {} 29 | } 30 | -------------------------------------------------------------------------------- /src/structs/raw.rs: -------------------------------------------------------------------------------- 1 | //! structs of raw_data. 2 | 3 | mod raw_file; 4 | pub(crate) use self::raw_file::*; 5 | 6 | mod raw_worksheet; 7 | pub(crate) use self::raw_worksheet::*; 8 | 9 | mod raw_relationships; 10 | pub(crate) use self::raw_relationships::*; 11 | 12 | mod raw_relationship; 13 | pub(crate) use self::raw_relationship::*; 14 | -------------------------------------------------------------------------------- /src/structs/s_byte_value.rs: -------------------------------------------------------------------------------- 1 | #[derive(Clone, Default, Debug)] 2 | pub struct SByteValue { 3 | value: Option, 4 | } 5 | impl SByteValue { 6 | #[inline] 7 | pub(crate) fn get_value(&self) -> &i8 { 8 | self.value.as_ref().unwrap_or(&0) 9 | } 10 | 11 | #[inline] 12 | pub(crate) fn get_value_string(&self) -> String { 13 | self.get_value().to_string() 14 | } 15 | 16 | #[inline] 17 | pub(crate) fn set_value(&mut self, value: i8) -> &mut SByteValue { 18 | self.value = Some(value); 19 | self 20 | } 21 | 22 | #[inline] 23 | pub(crate) fn set_value_string>(&mut self, value: S) -> &mut SByteValue { 24 | self.set_value(value.into().parse::().unwrap()) 25 | } 26 | 27 | #[inline] 28 | pub(crate) fn _has_value(&self) -> bool { 29 | self.value.is_some() 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/structs/sheet_state_values.rs: -------------------------------------------------------------------------------- 1 | use super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug)] 4 | pub enum SheetStateValues { 5 | Hidden, 6 | VeryHidden, 7 | Visible, 8 | } 9 | impl Default for SheetStateValues { 10 | #[inline] 11 | fn default() -> Self { 12 | Self::Visible 13 | } 14 | } 15 | impl EnumTrait for SheetStateValues { 16 | #[inline] 17 | fn get_value_string(&self) -> &str { 18 | match &self { 19 | Self::Hidden => "hidden", 20 | Self::VeryHidden => "veryHidden", 21 | Self::Visible => "visible", 22 | } 23 | } 24 | } 25 | impl FromStr for SheetStateValues { 26 | type Err = (); 27 | 28 | #[inline] 29 | fn from_str(input: &str) -> Result { 30 | match input { 31 | "hidden" => Ok(Self::Hidden), 32 | "veryHidden" => Ok(Self::VeryHidden), 33 | "visible" => Ok(Self::Visible), 34 | _ => Err(()), 35 | } 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /src/structs/sheet_view_values.rs: -------------------------------------------------------------------------------- 1 | use super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug)] 4 | pub enum SheetViewValues { 5 | Normal, 6 | PageBreakPreview, 7 | PageLayout, 8 | } 9 | impl Default for SheetViewValues { 10 | #[inline] 11 | fn default() -> Self { 12 | Self::Normal 13 | } 14 | } 15 | impl EnumTrait for SheetViewValues { 16 | #[inline] 17 | fn get_value_string(&self) -> &str { 18 | match &self { 19 | Self::Normal => "normal", 20 | Self::PageBreakPreview => "pageBreakPreview", 21 | Self::PageLayout => "pageLayout", 22 | } 23 | } 24 | } 25 | impl FromStr for SheetViewValues { 26 | type Err = (); 27 | 28 | #[inline] 29 | fn from_str(input: &str) -> Result { 30 | match input { 31 | "normal" => Ok(Self::Normal), 32 | "pageBreakPreview" => Ok(Self::PageBreakPreview), 33 | "pageLayout" => Ok(Self::PageLayout), 34 | _ => Err(()), 35 | } 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /src/structs/source_values.rs: -------------------------------------------------------------------------------- 1 | use super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Debug, Clone, Eq, Ord, PartialEq, PartialOrd)] 4 | pub enum SourceValues { 5 | Consolidation, 6 | External, 7 | Scenario, 8 | Worksheet, 9 | } 10 | impl Default for SourceValues { 11 | fn default() -> Self { 12 | Self::Worksheet 13 | } 14 | } 15 | impl EnumTrait for SourceValues { 16 | fn get_value_string(&self) -> &str { 17 | match &self { 18 | Self::Consolidation => "consolidation", 19 | Self::External => "external", 20 | Self::Scenario => "scenario", 21 | Self::Worksheet => "worksheet", 22 | } 23 | } 24 | } 25 | impl FromStr for SourceValues { 26 | type Err = (); 27 | fn from_str(input: &str) -> Result { 28 | match input { 29 | "consolidation" => Ok(Self::Consolidation), 30 | "external" => Ok(Self::External), 31 | "scenario" => Ok(Self::Scenario), 32 | "worksheet" => Ok(Self::Worksheet), 33 | _ => Err(()), 34 | } 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/structs/true_false_value.rs: -------------------------------------------------------------------------------- 1 | #[derive(Clone, Default, Debug)] 2 | pub struct TrueFalseValue { 3 | value: Option, 4 | value_default: bool, 5 | } 6 | impl TrueFalseValue { 7 | #[inline] 8 | pub(crate) fn get_value(&self) -> &bool { 9 | self.value.as_ref().unwrap_or(&self.value_default) 10 | } 11 | 12 | #[inline] 13 | pub(crate) fn get_value_string(&self) -> &str { 14 | match self.get_value() { 15 | true => "t", 16 | false => "f", 17 | } 18 | } 19 | 20 | #[inline] 21 | pub(crate) fn set_value(&mut self, value: bool) -> &mut Self { 22 | self.value = Some(value); 23 | self 24 | } 25 | 26 | #[inline] 27 | pub(crate) fn set_value_string>(&mut self, value: S) -> &mut Self { 28 | let value: String = value.into(); 29 | self.set_value(!(value.eq_ignore_ascii_case("f") || value.eq_ignore_ascii_case("false"))) 30 | } 31 | 32 | #[inline] 33 | pub(crate) fn has_value(&self) -> bool { 34 | self.value.is_some() 35 | } 36 | 37 | #[inline] 38 | pub(crate) fn _get_hash_string(&self) -> &str { 39 | if self.has_value() { 40 | return self.get_value_string(); 41 | } 42 | "empty!!" 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /src/structs/u_int16_value.rs: -------------------------------------------------------------------------------- 1 | #[derive(Clone, Default, Debug)] 2 | pub struct UInt16Value { 3 | value: Option, 4 | } 5 | impl UInt16Value { 6 | #[inline] 7 | pub(crate) fn get_value(&self) -> &u16 { 8 | self.value.as_ref().unwrap_or(&0) 9 | } 10 | 11 | #[inline] 12 | pub(crate) fn get_value_string(&self) -> String { 13 | self.get_value().to_string() 14 | } 15 | 16 | #[inline] 17 | pub(crate) fn set_value(&mut self, value: u16) -> &mut UInt16Value { 18 | self.value = Some(value); 19 | self 20 | } 21 | 22 | #[inline] 23 | pub(crate) fn set_value_string>(&mut self, value: S) -> &mut UInt16Value { 24 | self.set_value(value.into().parse::().unwrap()) 25 | } 26 | 27 | #[inline] 28 | pub(crate) fn _has_value(&self) -> bool { 29 | self.value.is_some() 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/structs/u_int32_value.rs: -------------------------------------------------------------------------------- 1 | #[derive(Clone, Default, Debug, Eq, Ord, PartialEq, PartialOrd)] 2 | pub struct UInt32Value { 3 | value: Option, 4 | } 5 | impl UInt32Value { 6 | #[inline] 7 | pub(crate) fn get_value(&self) -> &u32 { 8 | self.value.as_ref().unwrap_or(&0) 9 | } 10 | 11 | #[inline] 12 | pub(crate) fn get_value_string(&self) -> String { 13 | self.get_value().to_string() 14 | } 15 | 16 | #[inline] 17 | pub(crate) fn set_value(&mut self, value: u32) -> &mut Self { 18 | self.value = Some(value); 19 | self 20 | } 21 | 22 | #[inline] 23 | pub(crate) fn set_value_string>(&mut self, value: S) -> &mut Self { 24 | self.set_value(value.into().parse::().unwrap()) 25 | } 26 | 27 | #[inline] 28 | pub(crate) fn remove_value(&mut self) -> &mut Self { 29 | self.value = None; 30 | self 31 | } 32 | 33 | #[inline] 34 | pub(crate) fn has_value(&self) -> bool { 35 | self.value.is_some() 36 | } 37 | 38 | #[inline] 39 | pub(crate) fn get_hash_string(&self) -> String { 40 | if self.has_value() { 41 | return self.get_value_string(); 42 | } 43 | String::from("empty!!") 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /src/structs/underline_values.rs: -------------------------------------------------------------------------------- 1 | use super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)] 4 | pub enum UnderlineValues { 5 | Double, 6 | DoubleAccounting, 7 | None, 8 | Single, 9 | SingleAccounting, 10 | } 11 | impl Default for UnderlineValues { 12 | #[inline] 13 | fn default() -> Self { 14 | Self::Single 15 | } 16 | } 17 | impl EnumTrait for UnderlineValues { 18 | #[inline] 19 | fn get_value_string(&self) -> &str { 20 | match &self { 21 | Self::Double => "double", 22 | Self::DoubleAccounting => "doubleAccounting", 23 | Self::None => "none", 24 | Self::Single => "single", 25 | Self::SingleAccounting => "singleAccounting", 26 | } 27 | } 28 | } 29 | impl FromStr for UnderlineValues { 30 | type Err = (); 31 | 32 | #[inline] 33 | fn from_str(input: &str) -> Result { 34 | match input { 35 | "double" => Ok(Self::Double), 36 | "doubleAccounting" => Ok(Self::DoubleAccounting), 37 | "none" => Ok(Self::None), 38 | "single" => Ok(Self::Single), 39 | "singleAccounting" => Ok(Self::SingleAccounting), 40 | _ => Err(()), 41 | } 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /src/structs/vertical_alignment_run_values.rs: -------------------------------------------------------------------------------- 1 | use super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)] 4 | pub enum VerticalAlignmentRunValues { 5 | Baseline, 6 | Subscript, 7 | Superscript, 8 | } 9 | impl Default for VerticalAlignmentRunValues { 10 | #[inline] 11 | fn default() -> Self { 12 | Self::Baseline 13 | } 14 | } 15 | impl EnumTrait for VerticalAlignmentRunValues { 16 | #[inline] 17 | fn get_value_string(&self) -> &str { 18 | match &self { 19 | Self::Baseline => "baseline", 20 | Self::Subscript => "subscript", 21 | Self::Superscript => "superscript", 22 | } 23 | } 24 | } 25 | impl FromStr for VerticalAlignmentRunValues { 26 | type Err = (); 27 | 28 | #[inline] 29 | fn from_str(input: &str) -> Result { 30 | match input { 31 | "baseline" => Ok(Self::Baseline), 32 | "subscript" => Ok(Self::Subscript), 33 | "superscript" => Ok(Self::Superscript), 34 | _ => Err(()), 35 | } 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /src/structs/vertical_alignment_values.rs: -------------------------------------------------------------------------------- 1 | use super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Debug, Clone, Eq, Ord, PartialEq, PartialOrd)] 4 | pub enum VerticalAlignmentValues { 5 | Bottom, 6 | Center, 7 | Distributed, 8 | Justify, 9 | Top, 10 | } 11 | impl Default for VerticalAlignmentValues { 12 | #[inline] 13 | fn default() -> Self { 14 | Self::Bottom 15 | } 16 | } 17 | impl EnumTrait for VerticalAlignmentValues { 18 | #[inline] 19 | fn get_value_string(&self) -> &str { 20 | match &self { 21 | Self::Bottom => "bottom", 22 | Self::Center => "center", 23 | Self::Distributed => "distributed", 24 | Self::Justify => "justify", 25 | Self::Top => "top", 26 | } 27 | } 28 | } 29 | impl FromStr for VerticalAlignmentValues { 30 | type Err = (); 31 | 32 | #[inline] 33 | fn from_str(input: &str) -> Result { 34 | match input { 35 | "bottom" => Ok(Self::Bottom), 36 | "center" => Ok(Self::Center), 37 | "distributed" => Ok(Self::Distributed), 38 | "justify" => Ok(Self::Justify), 39 | "top" => Ok(Self::Top), 40 | _ => Err(()), 41 | } 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /src/structs/vml.rs: -------------------------------------------------------------------------------- 1 | pub mod office; 2 | pub mod spreadsheet; 3 | 4 | mod shape; 5 | pub use self::shape::*; 6 | 7 | mod fill; 8 | pub use self::fill::*; 9 | 10 | mod stroke; 11 | pub use self::stroke::*; 12 | 13 | mod image_data; 14 | pub use self::image_data::*; 15 | 16 | mod shadow; 17 | pub use self::shadow::*; 18 | 19 | mod path; 20 | pub use self::path::*; 21 | 22 | mod text_box; 23 | pub use self::text_box::*; 24 | -------------------------------------------------------------------------------- /src/structs/vml/office.rs: -------------------------------------------------------------------------------- 1 | mod inset_margin_values; 2 | pub use self::inset_margin_values::*; 3 | 4 | mod connect_values; 5 | pub use self::connect_values::*; 6 | -------------------------------------------------------------------------------- /src/structs/vml/office/connect_values.rs: -------------------------------------------------------------------------------- 1 | use super::super::super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug)] 4 | pub enum ConnectValues { 5 | Custom, 6 | None, 7 | Rectangle, 8 | Segments, 9 | } 10 | impl Default for ConnectValues { 11 | fn default() -> Self { 12 | Self::None 13 | } 14 | } 15 | impl EnumTrait for ConnectValues { 16 | fn get_value_string(&self) -> &str { 17 | match &self { 18 | Self::Custom => "custom", 19 | Self::None => "none", 20 | Self::Rectangle => "rect", 21 | Self::Segments => "segments", 22 | } 23 | } 24 | } 25 | impl FromStr for ConnectValues { 26 | type Err = (); 27 | fn from_str(input: &str) -> Result { 28 | match input { 29 | "custom" => Ok(Self::Custom), 30 | "none" => Ok(Self::None), 31 | "rect" => Ok(Self::Rectangle), 32 | "segments" => Ok(Self::Segments), 33 | _ => Err(()), 34 | } 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /src/structs/vml/office/inset_margin_values.rs: -------------------------------------------------------------------------------- 1 | use super::super::super::EnumTrait; 2 | use std::str::FromStr; 3 | #[derive(Clone, Debug)] 4 | pub enum InsetMarginValues { 5 | Auto, 6 | Custom, 7 | } 8 | impl Default for InsetMarginValues { 9 | fn default() -> Self { 10 | Self::Auto 11 | } 12 | } 13 | impl EnumTrait for InsetMarginValues { 14 | fn get_value_string(&self) -> &str { 15 | match &self { 16 | Self::Auto => "auto", 17 | Self::Custom => "custom", 18 | } 19 | } 20 | } 21 | impl FromStr for InsetMarginValues { 22 | type Err = (); 23 | fn from_str(input: &str) -> Result { 24 | match input { 25 | "auto" => Ok(Self::Auto), 26 | "custom" => Ok(Self::Custom), 27 | _ => Err(()), 28 | } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/structs/vml/spreadsheet.rs: -------------------------------------------------------------------------------- 1 | mod object_values; 2 | pub use self::object_values::*; 3 | 4 | mod client_data; 5 | pub use self::client_data::*; 6 | 7 | mod resize_with_cells; 8 | pub use self::resize_with_cells::*; 9 | 10 | mod anchor; 11 | pub use self::anchor::*; 12 | 13 | mod clipboard_format; 14 | pub use self::clipboard_format::*; 15 | 16 | mod move_with_cells; 17 | pub use self::move_with_cells::*; 18 | 19 | mod auto_fill; 20 | pub use self::auto_fill::*; 21 | 22 | mod comment_row_target; 23 | pub use self::comment_row_target::*; 24 | 25 | mod comment_column_target; 26 | pub use self::comment_column_target::*; 27 | 28 | mod visible; 29 | pub use self::visible::*; 30 | 31 | mod clipboard_format_values; 32 | pub use self::clipboard_format_values::*; 33 | 34 | mod auto_size_picture; 35 | pub use self::auto_size_picture::*; 36 | -------------------------------------------------------------------------------- /src/traits.rs: -------------------------------------------------------------------------------- 1 | //! store structs. 2 | 3 | mod adjustment_coordinate_with_sheet; 4 | pub use self::adjustment_coordinate_with_sheet::*; 5 | 6 | mod adjustment_coordinate; 7 | pub use self::adjustment_coordinate::*; 8 | 9 | mod adjustment_coordinate_with_2sheet; 10 | pub use self::adjustment_coordinate_with_2sheet::*; 11 | 12 | mod adjustment_value; 13 | pub use self::adjustment_value::*; 14 | -------------------------------------------------------------------------------- /src/traits/adjustment_coordinate.rs: -------------------------------------------------------------------------------- 1 | pub(crate) trait AdjustmentCoordinate { 2 | fn adjustment_insert_coordinate( 3 | &mut self, 4 | root_col_num: &u32, 5 | offset_col_num: &u32, 6 | root_row_num: &u32, 7 | offset_row_num: &u32, 8 | ); 9 | 10 | fn adjustment_remove_coordinate( 11 | &mut self, 12 | root_col_num: &u32, 13 | offset_col_num: &u32, 14 | root_row_num: &u32, 15 | offset_row_num: &u32, 16 | ); 17 | 18 | fn is_remove_coordinate( 19 | &self, 20 | root_col_num: &u32, 21 | offset_col_num: &u32, 22 | root_row_num: &u32, 23 | offset_row_num: &u32, 24 | ) -> bool { 25 | false 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/traits/adjustment_coordinate_with_2sheet.rs: -------------------------------------------------------------------------------- 1 | pub(crate) trait AdjustmentCoordinateWith2Sheet { 2 | fn adjustment_insert_coordinate_with_2sheet( 3 | &mut self, 4 | self_sheet_name: &str, 5 | sheet_name: &str, 6 | root_col_num: &u32, 7 | offset_col_num: &u32, 8 | root_row_num: &u32, 9 | offset_row_num: &u32, 10 | ); 11 | 12 | fn adjustment_remove_coordinate_with_2sheet( 13 | &mut self, 14 | self_sheet_name: &str, 15 | sheet_name: &str, 16 | root_col_num: &u32, 17 | offset_col_num: &u32, 18 | root_row_num: &u32, 19 | offset_row_num: &u32, 20 | ); 21 | 22 | fn is_remove_coordinate_with_2sheet( 23 | &self, 24 | sheet_name: &str, 25 | root_col_num: &u32, 26 | offset_col_num: &u32, 27 | root_row_num: &u32, 28 | offset_row_num: &u32, 29 | ) -> bool { 30 | false 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/traits/adjustment_coordinate_with_sheet.rs: -------------------------------------------------------------------------------- 1 | pub(crate) trait AdjustmentCoordinateWithSheet { 2 | fn adjustment_insert_coordinate_with_sheet( 3 | &mut self, 4 | sheet_name: &str, 5 | root_col_num: &u32, 6 | offset_col_num: &u32, 7 | root_row_num: &u32, 8 | offset_row_num: &u32, 9 | ); 10 | 11 | fn adjustment_remove_coordinate_with_sheet( 12 | &mut self, 13 | sheet_name: &str, 14 | root_col_num: &u32, 15 | offset_col_num: &u32, 16 | root_row_num: &u32, 17 | offset_row_num: &u32, 18 | ); 19 | 20 | fn is_remove_coordinate_with_sheet( 21 | &self, 22 | sheet_name: &str, 23 | root_col_num: &u32, 24 | offset_col_num: &u32, 25 | root_row_num: &u32, 26 | offset_row_num: &u32, 27 | ) -> bool { 28 | false 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/traits/adjustment_value.rs: -------------------------------------------------------------------------------- 1 | pub(crate) trait AdjustmentValue { 2 | fn adjustment_insert_value(&mut self, root_num: &u32, offset_num: &u32); 3 | 4 | fn adjustment_remove_value(&mut self, root_num: &u32, offset_num: &u32); 5 | 6 | fn is_remove_value(&self, root_num: &u32, offset_num: &u32) -> bool { 7 | false 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /src/writer.rs: -------------------------------------------------------------------------------- 1 | //! file writer library. 2 | 3 | pub mod csv; 4 | pub(crate) mod driver; 5 | pub mod xlsx; 6 | -------------------------------------------------------------------------------- /src/writer/xlsx/chart.rs: -------------------------------------------------------------------------------- 1 | use super::driver::*; 2 | use super::XlsxError; 3 | use crate::structs::drawing::charts::ChartSpace; 4 | use crate::structs::Spreadsheet; 5 | use crate::structs::WriterManager; 6 | use quick_xml::events::{BytesDecl, Event}; 7 | use quick_xml::Writer; 8 | use std::io; 9 | 10 | pub(crate) fn write( 11 | chart_space: &ChartSpace, 12 | spreadsheet: &Spreadsheet, 13 | writer_mng: &mut WriterManager, 14 | ) -> Result { 15 | let mut writer = Writer::new(io::Cursor::new(Vec::new())); 16 | // XML header 17 | writer.write_event(Event::Decl(BytesDecl::new( 18 | "1.0", 19 | Some("UTF-8"), 20 | Some("yes"), 21 | ))); 22 | write_new_line(&mut writer); 23 | 24 | // c:chartSpace 25 | chart_space.write_to(&mut writer, spreadsheet); 26 | 27 | let file_no = writer_mng.add_file_at_chart(writer)?; 28 | Ok(file_no.to_string()) 29 | } 30 | -------------------------------------------------------------------------------- /src/writer/xlsx/doc_props_app.rs: -------------------------------------------------------------------------------- 1 | use quick_xml::events::{BytesDecl, Event}; 2 | use quick_xml::Writer; 3 | use std::io; 4 | 5 | use super::driver::*; 6 | use super::XlsxError; 7 | use crate::helper::const_str::*; 8 | use crate::structs::Spreadsheet; 9 | use crate::structs::WriterManager; 10 | 11 | pub(crate) fn write( 12 | spreadsheet: &Spreadsheet, 13 | writer_mng: &mut WriterManager, 14 | ) -> Result<(), XlsxError> { 15 | let mut writer = Writer::new(io::Cursor::new(Vec::new())); 16 | // XML header 17 | writer.write_event(Event::Decl(BytesDecl::new( 18 | "1.0", 19 | Some("UTF-8"), 20 | Some("yes"), 21 | ))); 22 | write_new_line(&mut writer); 23 | 24 | // Properties 25 | spreadsheet 26 | .get_properties() 27 | .write_to_app(&mut writer, spreadsheet.get_sheet_collection_no_check()); 28 | 29 | writer_mng.add_writer(ARC_APP, writer) 30 | } 31 | -------------------------------------------------------------------------------- /src/writer/xlsx/doc_props_core.rs: -------------------------------------------------------------------------------- 1 | use quick_xml::events::{BytesDecl, Event}; 2 | use quick_xml::Writer; 3 | use std::io; 4 | 5 | use super::driver::*; 6 | use super::XlsxError; 7 | use crate::helper::const_str::*; 8 | use crate::structs::Spreadsheet; 9 | use crate::structs::WriterManager; 10 | 11 | pub(crate) fn write( 12 | spreadsheet: &Spreadsheet, 13 | writer_mng: &mut WriterManager, 14 | ) -> Result<(), XlsxError> { 15 | let mut writer = Writer::new(io::Cursor::new(Vec::new())); 16 | // XML header 17 | writer.write_event(Event::Decl(BytesDecl::new( 18 | "1.0", 19 | Some("UTF-8"), 20 | Some("yes"), 21 | ))); 22 | write_new_line(&mut writer); 23 | 24 | // cp:coreProperties 25 | spreadsheet.get_properties().write_to_core(&mut writer); 26 | 27 | writer_mng.add_writer(ARC_CORE, writer) 28 | } 29 | -------------------------------------------------------------------------------- /src/writer/xlsx/doc_props_custom.rs: -------------------------------------------------------------------------------- 1 | use quick_xml::events::{BytesDecl, Event}; 2 | use quick_xml::Writer; 3 | use std::io; 4 | 5 | use super::driver::*; 6 | use super::XlsxError; 7 | use crate::helper::const_str::*; 8 | use crate::structs::Spreadsheet; 9 | use crate::structs::WriterManager; 10 | 11 | pub(crate) fn write( 12 | spreadsheet: &Spreadsheet, 13 | writer_mng: &mut WriterManager, 14 | ) -> Result<(), XlsxError> { 15 | if spreadsheet 16 | .get_properties() 17 | .get_custom_properties() 18 | .get_custom_document_property_list() 19 | .is_empty() 20 | { 21 | return Ok(()); 22 | } 23 | 24 | let mut writer = Writer::new(io::Cursor::new(Vec::new())); 25 | // XML header 26 | writer.write_event(Event::Decl(BytesDecl::new( 27 | "1.0", 28 | Some("UTF-8"), 29 | Some("yes"), 30 | ))); 31 | write_new_line(&mut writer); 32 | 33 | // Properties 34 | spreadsheet.get_properties().write_to_custom(&mut writer); 35 | 36 | writer_mng.add_writer(ARC_CUSTOM, writer) 37 | } 38 | -------------------------------------------------------------------------------- /src/writer/xlsx/drawing.rs: -------------------------------------------------------------------------------- 1 | use quick_xml::events::{BytesDecl, Event}; 2 | use quick_xml::Writer; 3 | use std::io; 4 | 5 | use super::driver::*; 6 | use super::XlsxError; 7 | use crate::structs::Worksheet; 8 | use crate::structs::WriterManager; 9 | 10 | pub(crate) fn write( 11 | worksheet: &Worksheet, 12 | writer_mng: &mut WriterManager, 13 | ) -> Result<(String, Vec<(String, String)>), XlsxError> { 14 | let mut rel_list: Vec<(String, String)> = Vec::new(); 15 | 16 | if !worksheet.has_drawing_object() { 17 | return Ok((String::new(), rel_list)); 18 | } 19 | 20 | let mut writer = Writer::new(io::Cursor::new(Vec::new())); 21 | // XML header 22 | writer.write_event(Event::Decl(BytesDecl::new( 23 | "1.0", 24 | Some("UTF-8"), 25 | Some("yes"), 26 | ))); 27 | write_new_line(&mut writer); 28 | 29 | worksheet.get_worksheet_drawing().write_to( 30 | &mut writer, 31 | worksheet.get_ole_objects(), 32 | &mut rel_list, 33 | ); 34 | 35 | let file_no = writer_mng.add_file_at_drawing(writer)?; 36 | Ok((file_no.to_string(), rel_list)) 37 | } 38 | -------------------------------------------------------------------------------- /src/writer/xlsx/embeddings.rs: -------------------------------------------------------------------------------- 1 | use std::io; 2 | 3 | use super::XlsxError; 4 | use crate::structs::Worksheet; 5 | use crate::structs::WriterManager; 6 | 7 | pub(crate) fn write( 8 | worksheet: &Worksheet, 9 | writer_mng: &mut WriterManager, 10 | ) -> Result<(Vec, Vec), XlsxError> { 11 | let mut ole_object_no_list: Vec = Vec::new(); 12 | let mut excel_no_list: Vec = Vec::new(); 13 | for ole_object in worksheet.get_ole_objects().get_ole_object() { 14 | if ole_object.is_bin() { 15 | let writer = ole_object.get_object_data().unwrap(); 16 | let file_no = writer_mng.add_file_at_ole_object(writer)?; 17 | ole_object_no_list.push(file_no.to_string()); 18 | } 19 | if ole_object.is_xlsx() { 20 | let writer = ole_object.get_object_data().unwrap(); 21 | let file_no = writer_mng.add_file_at_excel(writer)?; 22 | excel_no_list.push(file_no.to_string()); 23 | } 24 | } 25 | 26 | Ok((ole_object_no_list, excel_no_list)) 27 | } 28 | -------------------------------------------------------------------------------- /src/writer/xlsx/media.rs: -------------------------------------------------------------------------------- 1 | use std::io; 2 | 3 | use super::XlsxError; 4 | use crate::helper::const_str::*; 5 | use crate::structs::Worksheet; 6 | use crate::structs::WriterManager; 7 | 8 | pub(crate) fn write( 9 | worksheet: &Worksheet, 10 | writer_mng: &mut WriterManager, 11 | ) -> Result<(), XlsxError> { 12 | for image in worksheet.get_media_object_collection() { 13 | let file_name = format!("{PKG_MEDIA}/{}", image.get_image_name()); 14 | writer_mng.add_bin(&file_name, image.get_image_data())?; 15 | } 16 | Ok(()) 17 | } 18 | -------------------------------------------------------------------------------- /src/writer/xlsx/printer_settings.rs: -------------------------------------------------------------------------------- 1 | use std::io; 2 | 3 | use super::XlsxError; 4 | use crate::structs::Worksheet; 5 | use crate::structs::WriterManager; 6 | 7 | #[inline] 8 | pub(crate) fn write( 9 | worksheet: &Worksheet, 10 | writer_mng: &mut WriterManager, 11 | ) -> Result { 12 | let writer = worksheet.get_page_setup().get_object_data().unwrap(); 13 | 14 | let file_no = writer_mng.add_file_at_printer_settings(writer)?; 15 | Ok(file_no.to_string()) 16 | } 17 | -------------------------------------------------------------------------------- /src/writer/xlsx/shared_strings.rs: -------------------------------------------------------------------------------- 1 | use super::driver::*; 2 | use super::XlsxError; 3 | use crate::helper::const_str::*; 4 | use crate::structs::SharedStringTable; 5 | use crate::structs::WriterManager; 6 | use quick_xml::events::{BytesDecl, Event}; 7 | use quick_xml::Writer; 8 | use std::io; 9 | use std::result; 10 | use std::sync::Arc; 11 | use std::sync::RwLock; 12 | 13 | pub(crate) fn write( 14 | shared_string_table: &RwLock, 15 | writer_mng: &mut WriterManager, 16 | ) -> result::Result<(), XlsxError> { 17 | if shared_string_table 18 | .read() 19 | .unwrap() 20 | .get_shared_string_item() 21 | .is_empty() 22 | { 23 | return Ok(()); 24 | } 25 | 26 | let mut writer = Writer::new(io::Cursor::new(Vec::new())); 27 | // XML header 28 | writer.write_event(Event::Decl(BytesDecl::new( 29 | "1.0", 30 | Some("UTF-8"), 31 | Some("yes"), 32 | ))); 33 | write_new_line(&mut writer); 34 | 35 | shared_string_table.write().unwrap().write_to(&mut writer); 36 | 37 | writer_mng.add_writer(PKG_SHARED_STRINGS, writer) 38 | } 39 | -------------------------------------------------------------------------------- /src/writer/xlsx/styles.rs: -------------------------------------------------------------------------------- 1 | use super::driver::*; 2 | use super::XlsxError; 3 | use crate::helper::const_str::*; 4 | use crate::structs::Stylesheet; 5 | use crate::structs::WriterManager; 6 | use quick_xml::events::{BytesDecl, Event}; 7 | use quick_xml::Writer; 8 | use std::io; 9 | 10 | pub(crate) fn write( 11 | stylesheet: &Stylesheet, 12 | writer_mng: &mut WriterManager, 13 | ) -> Result<(), XlsxError> { 14 | let mut writer = Writer::new(io::Cursor::new(Vec::new())); 15 | // XML header 16 | writer.write_event(Event::Decl(BytesDecl::new( 17 | "1.0", 18 | Some("UTF-8"), 19 | Some("yes"), 20 | ))); 21 | write_new_line(&mut writer); 22 | 23 | stylesheet.write_to(&mut writer); 24 | 25 | writer_mng.add_writer(PKG_STYLES, writer) 26 | } 27 | -------------------------------------------------------------------------------- /src/writer/xlsx/theme.rs: -------------------------------------------------------------------------------- 1 | use quick_xml::events::{BytesDecl, Event}; 2 | use quick_xml::Writer; 3 | use std::io; 4 | 5 | use super::driver::*; 6 | use super::XlsxError; 7 | use crate::helper::const_str::*; 8 | use crate::structs::drawing::Theme; 9 | use crate::structs::WriterManager; 10 | 11 | pub(crate) fn write( 12 | theme: &Theme, 13 | writer_mng: &mut WriterManager, 14 | ) -> Result<(), XlsxError> { 15 | let mut writer = Writer::new(io::Cursor::new(Vec::new())); 16 | // XML header 17 | writer.write_event(Event::Decl(BytesDecl::new( 18 | "1.0", 19 | Some("UTF-8"), 20 | Some("yes"), 21 | ))); 22 | write_new_line(&mut writer); 23 | 24 | // a:theme 25 | theme.write_to(&mut writer); 26 | 27 | writer_mng.add_writer(PKG_THEME, writer) 28 | } 29 | -------------------------------------------------------------------------------- /src/writer/xlsx/vba_project_bin.rs: -------------------------------------------------------------------------------- 1 | use std::io; 2 | 3 | use super::XlsxError; 4 | use crate::helper::const_str::*; 5 | use crate::structs::Spreadsheet; 6 | use crate::structs::WriterManager; 7 | 8 | pub(crate) fn write( 9 | spreadsheet: &Spreadsheet, 10 | writer_mng: &mut WriterManager, 11 | ) -> Result<(), XlsxError> { 12 | if !spreadsheet.get_has_macros() { 13 | return Ok(()); 14 | } 15 | let writer = spreadsheet.get_macros_code().unwrap(); 16 | writer_mng.add_bin(PKG_VBA_PROJECT, writer) 17 | } 18 | -------------------------------------------------------------------------------- /tests/result_files/.gitignore: -------------------------------------------------------------------------------- 1 | * 2 | !.gitignore 3 | -------------------------------------------------------------------------------- /tests/test_files/aaa.xlsm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/aaa.xlsm -------------------------------------------------------------------------------- /tests/test_files/aaa.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/aaa.xlsx -------------------------------------------------------------------------------- /tests/test_files/aaa_2.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/aaa_2.xlsx -------------------------------------------------------------------------------- /tests/test_files/aaa_empty.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/aaa_empty.xlsx -------------------------------------------------------------------------------- /tests/test_files/aaa_insertCell.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/aaa_insertCell.xlsx -------------------------------------------------------------------------------- /tests/test_files/aaa_large.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/aaa_large.xlsx -------------------------------------------------------------------------------- /tests/test_files/aaa_large_string.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/aaa_large_string.xlsx -------------------------------------------------------------------------------- /tests/test_files/aaa_move_range.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/aaa_move_range.xlsx -------------------------------------------------------------------------------- /tests/test_files/aaa_theme.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/aaa_theme.xlsx -------------------------------------------------------------------------------- /tests/test_files/book_lock.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/book_lock.xlsx -------------------------------------------------------------------------------- /tests/test_files/google.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/google.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_147.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_147.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_162.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_162.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_178.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_178.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_178_2.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_178_2.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_181.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_181.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_181_2.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_181_2.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_184.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_184.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_184_2.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_184_2.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_185.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_185.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_187.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_187.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_188.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_188.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_188_2.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_188_2.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_188_3.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_188_3.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_188_4.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_188_4.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_189.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_189.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_190.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_190.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_194.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_194.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_194_2.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_194_2.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_200.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_200.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_201.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_201.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_206.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_206.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_208.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_208.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_210.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_210.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_215.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_215.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_216.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_216.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_217.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_217.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_219.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_219.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_220.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_220.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_222.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_222.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_225.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_225.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_232.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_232.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_233.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_233.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_244.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_244.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_246.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_246.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_268.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_268.xlsx -------------------------------------------------------------------------------- /tests/test_files/issue_281.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/issue_281.xlsx -------------------------------------------------------------------------------- /tests/test_files/libre.xlsm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/libre.xlsm -------------------------------------------------------------------------------- /tests/test_files/libre2.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/libre2.xlsx -------------------------------------------------------------------------------- /tests/test_files/openpyxl.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/openpyxl.xlsx -------------------------------------------------------------------------------- /tests/test_files/pr_204.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/pr_204.xlsx -------------------------------------------------------------------------------- /tests/test_files/red_indexed_color.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/red_indexed_color.xlsx -------------------------------------------------------------------------------- /tests/test_files/sheet_lock.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/sheet_lock.xlsx -------------------------------------------------------------------------------- /tests/test_files/table.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/table.xlsx -------------------------------------------------------------------------------- /tests/test_files/wb_with_shared_strings.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/wb_with_shared_strings.xlsx -------------------------------------------------------------------------------- /tests/test_files/wps_comment.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/MathNya/umya-spreadsheet/e744ca0f63ee7b57134f3cb17f2c8a9d27c7b8ad/tests/test_files/wps_comment.xlsx --------------------------------------------------------------------------------