UPDATE: Adds get/set views to the user model API (#69)

xlsx/src/import/mod.rs

@@ -16,7 +16,7 @@ use std::{
 use roxmltree::Node;
 
 use ironcalc_base::{
-    types::{Metadata, Workbook, WorkbookSettings},
+    types::{Metadata, Workbook, WorkbookSettings, WorkbookView},
     Model,
 };
 
@@ -66,7 +66,7 @@ fn load_xlsx_from_reader<R: Read + std::io::Seek>(
     let workbook = load_workbook(&mut archive)?;
     let rels = load_relationships(&mut archive)?;
     let mut tables = HashMap::new();
-    let worksheets = load_sheets(
+    let (worksheets, selected_sheet) = load_sheets(
         &mut archive,
         &rels,
         &workbook,
@@ -88,6 +88,13 @@ fn load_xlsx_from_reader<R: Read + std::io::Seek>(
             }
         }
     };
+    let mut views = HashMap::new();
+    views.insert(
+        0,
+        WorkbookView {
+            sheet: selected_sheet,
+        },
+    );
     Ok(Workbook {
         shared_strings,
         defined_names: workbook.defined_names,
@@ -100,6 +107,7 @@ fn load_xlsx_from_reader<R: Read + std::io::Seek>(
         },
         metadata,
         tables,
+        views,
     })
 }
 

xlsx/src/import/worksheets.rs

@@ -8,7 +8,8 @@ use ironcalc_base::{
         utils::{column_to_number, parse_reference_a1},
     },
     types::{
-        Cell, Col, Comment, DefinedName, Row, Selection, SheetData, SheetState, Table, Worksheet,
+        Cell, Col, Comment, DefinedName, Row, SheetData, SheetState, Table, Worksheet,
+        WorksheetView,
     },
 };
 use roxmltree::Node;
@@ -674,7 +675,7 @@ pub(super) fn load_sheet<R: Read + std::io::Seek>(
     worksheets: &[String],
     tables: &HashMap<String, Table>,
     shared_strings: &mut Vec<String>,
-) -> Result<Worksheet, XlsxError> {
+) -> Result<(Worksheet, bool), XlsxError> {
     let sheet_name = &settings.name;
     let sheet_id = settings.id;
     let state = &settings.state;
@@ -952,27 +953,37 @@ pub(super) fn load_sheet<R: Read + std::io::Seek>(
     // pageSetup
     // <pageSetup orientation="portrait" r:id="rId1"/>
 
-    Ok(Worksheet {
-        dimension,
-        cols,
-        rows,
-        shared_formulas,
-        sheet_data,
-        name: sheet_name.to_string(),
-        sheet_id,
-        state: state.to_owned(),
-        color,
-        merge_cells,
-        comments: settings.comments,
-        frozen_rows: sheet_view.frozen_rows,
-        frozen_columns: sheet_view.frozen_columns,
-        selection: Selection {
-            is_selected: sheet_view.is_selected,
+    let mut views = HashMap::new();
+    views.insert(
+        0,
+        WorksheetView {
             row: sheet_view.selected_row,
             column: sheet_view.selected_column,
             range: sheet_view.range,
+            top_row: 1,
+            left_column: 1,
         },
-    })
+    );
+
+    Ok((
+        Worksheet {
+            dimension,
+            cols,
+            rows,
+            shared_formulas,
+            sheet_data,
+            name: sheet_name.to_string(),
+            sheet_id,
+            state: state.to_owned(),
+            color,
+            merge_cells,
+            comments: settings.comments,
+            frozen_rows: sheet_view.frozen_rows,
+            frozen_columns: sheet_view.frozen_columns,
+            views,
+        },
+        sheet_view.is_selected,
+    ))
 }
 
 pub(super) fn load_sheets<R: Read + std::io::Seek>(
@@ -981,7 +992,7 @@ pub(super) fn load_sheets<R: Read + std::io::Seek>(
     workbook: &WorkbookXML,
     tables: &mut HashMap<String, Table>,
     shared_strings: &mut Vec<String>,
-) -> Result<Vec<Worksheet>, XlsxError> {
+) -> Result<(Vec<Worksheet>, u32), XlsxError> {
     // load comments and tables
     let mut comments = HashMap::new();
     for sheet in &workbook.worksheets {
@@ -1003,6 +1014,8 @@ pub(super) fn load_sheets<R: Read + std::io::Seek>(
     // load all sheets
     let worksheets: &Vec<String> = &workbook.worksheets.iter().map(|s| s.name.clone()).collect();
     let mut sheets = Vec::new();
+    let mut selected_sheet = 0;
+    let mut sheet_index = 0;
     for sheet in &workbook.worksheets {
         let sheet_name = &sheet.name;
         let rel_id = &sheet.id;
@@ -1021,15 +1034,14 @@ pub(super) fn load_sheets<R: Read + std::io::Seek>(
                 state: state.clone(),
                 comments: comments.get(rel_id).expect("").to_vec(),
             };
-            sheets.push(load_sheet(
-                archive,
-                &path,
-                settings,
-                worksheets,
-                tables,
-                shared_strings,
-            )?);
+            let (s, is_selected) =
+                load_sheet(archive, &path, settings, worksheets, tables, shared_strings)?;
+            if is_selected {
+                selected_sheet = sheet_index;
+            }
+            sheets.push(s);
+            sheet_index += 1;
         }
     }
-    Ok(sheets)
+    Ok((sheets, selected_sheet))
 }

xlsx/tests/test.rs

@@ -16,33 +16,32 @@ fn test_example() {
     let workbook = model.workbook;
     let ws = &workbook.worksheets;
     let expected_names = vec![
-        ("Sheet1".to_string(), false),
-        ("Second".to_string(), false),
-        ("Sheet4".to_string(), false),
-        ("shared".to_string(), false),
-        ("Table".to_string(), false),
-        ("Sheet2".to_string(), false),
-        ("Created fourth".to_string(), false),
-        ("Frozen".to_string(), true),
-        ("Split".to_string(), false),
-        ("Hidden".to_string(), false),
+        "Sheet1".to_string(),
+        "Second".to_string(),
+        "Sheet4".to_string(),
+        "shared".to_string(),
+        "Table".to_string(),
+        "Sheet2".to_string(),
+        "Created fourth".to_string(),
+        "Frozen".to_string(),
+        "Split".to_string(),
+        "Hidden".to_string(),
     ];
-    let names: Vec<(String, bool)> = ws
-        .iter()
-        .map(|s| (s.name.clone(), s.selection.is_selected))
-        .collect();
+    let names: Vec<String> = ws.iter().map(|s| s.name.clone()).collect();
 
     // One is not not imported and one is hidden
     assert_eq!(expected_names, names);
 
+    assert_eq!(workbook.views[&0].sheet, 7);
+
     // Test selection:
     // First sheet (Sheet1)
     // E13 and E13:N20
     assert_eq!(ws[0].frozen_rows, 0);
     assert_eq!(ws[0].frozen_columns, 0);
-    assert_eq!(ws[0].selection.row, 13);
-    assert_eq!(ws[0].selection.column, 5);
-    assert_eq!(ws[0].selection.range, [13, 5, 20, 14]);
+    assert_eq!(ws[0].views[&0].row, 13);
+    assert_eq!(ws[0].views[&0].column, 5);
+    assert_eq!(ws[0].views[&0].range, [13, 5, 20, 14]);
 
     let model2 = load_from_icalc("tests/example.ic").unwrap();
     let s = bitcode::encode(&model2.workbook);