FIX: Correct tag number (oops)

UPDATE: Adds CHANGELOG
Adds navigation labels for sheet management
2024-11-15 01:07:02 +01:00 · 2024-11-15 00:59:13 +01:00 · 2024-11-11 10:36:54 +01:00 · 2024-10-31 22:43:43 +01:00 · 2024-10-31 22:43:43 +01:00 · 2024-10-31 22:43:43 +01:00
211 changed files with 13451 additions and 21206 deletions
--- a/.github/workflows/test-coverage.yaml
+++ b/.github/workflows/test-coverage.yaml
@@ -1,6 +1,6 @@
 name: Coverage

-on: [pull_request, push]
+on: [pull_request]

 jobs:
  coverage:
@@ -14,7 +14,7 @@ jobs:
      - name: Install cargo-llvm-cov
        uses: taiki-e/install-action@cargo-llvm-cov
      - name: Generate code coverage
-        run: cargo llvm-cov --all-features --workspace --lcov --output-path lcov.info
+        run: cargo llvm-cov --all-features --workspace --exclude pyroncalc --exclude wasm --lcov --output-path lcov.info
      - name: Upload coverage to Codecov
        uses: codecov/codecov-action@v3
        with:
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,2 @@
-target/*
+target/*
+.DS_Store
--- a/.readthedocs.yaml
+++ b/.readthedocs.yaml
@@ -0,0 +1,32 @@
+# .readthedocs.yaml
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+
+# Set the OS, Python version and other tools you might need
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.12"
+    # You can also specify other tool versions:
+    # nodejs: "19"
+    # rust: "1.64"
+    # golang: "1.19"
+
+# Build documentation in the "docs/" directory with Sphinx
+sphinx:
+  configuration: bindings/python/docs/conf.py
+
+# Optionally build your docs in additional formats such as PDF and ePub
+# formats:
+#    - pdf
+#    - epub
+
+# Optional but recommended, declare the Python requirements required
+# to build your documentation
+# See https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html
+# python:
+#    install:
+#    - requirements: docs/requirements.txt
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -0,0 +1,15 @@
+# CHANGELOG
+
+## [Unreleased]
+
+## [0.2.0] - 2024-11-06 (The HN release)
+
+### Added
+
+- Rust crate ironcalc_base
+- Rust crate ironcalc
+- Minimal Python bindings (only Linux)
+- JavaScript bindings
+- React WebApp
+
+[0.2.0]: https://github.com/IronCalc/ironcalc/releases/tag/v0.2.0
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -19,6 +19,15 @@ dependencies = [
 "cpufeatures",
 ]

+[[package]]
+name = "aho-corasick"
+version = "0.6.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81ce3d38065e618af2d7b77e10c5ad9a069859b4be3c2250f674af3840d9c8a5"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "aho-corasick"
 version = "1.1.3"
@@ -76,6 +85,12 @@ dependencies = [
 "syn",
 ]

+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
 [[package]]
 name = "block-buffer"
 version = "0.10.4"
@@ -242,6 +257,40 @@ dependencies = [
 "typenum",
 ]

+[[package]]
+name = "csv"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac574ff4d437a7b5ad237ef331c17ccca63c46479e5b5453eb8e10bb99a759fe"
+dependencies = [
+ "csv-core",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "csv-core"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5efa2b3d7902f4b634a20cae3c9c4e6209dc4779feb6863329607560143efa70"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "csv-sniffer"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b8e952164bb270a505d6cb6136624174c34cfb9abd16e0011f5e53058317f39"
+dependencies = [
+ "bitflags",
+ "csv",
+ "csv-core",
+ "memchr",
+ "regex 0.2.11",
+]
+
 [[package]]
 name = "deranged"
 version = "0.3.11"
@@ -299,6 +348,12 @@ dependencies = [
 "wasi",
 ]

+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
 [[package]]
 name = "hmac"
 version = "0.12.1"
@@ -331,6 +386,12 @@ dependencies = [
 "cc",
 ]

+[[package]]
+name = "indoc"
+version = "2.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b248f5224d1d606005e02c97f5aa4e88eeb230488bcc03bc9ca4d7991399f2b5"
+
 [[package]]
 name = "inout"
 version = "0.1.3"
@@ -342,7 +403,7 @@ dependencies = [

 [[package]]
 name = "ironcalc"
-version = "0.1.3"
+version = "0.2.0"
 dependencies = [
 "bitcode",
 "chrono",
@@ -358,19 +419,20 @@ dependencies = [

 [[package]]
 name = "ironcalc_base"
-version = "0.1.3"
+version = "0.2.0"
 dependencies = [
 "bitcode",
 "chrono",
 "chrono-tz",
+ "csv",
+ "csv-sniffer",
 "js-sys",
 "once_cell",
 "rand",
- "regex",
+ "regex 1.10.4",
 "ryu",
 "serde",
 "serde_json",
- "serde_repr",
 ]

 [[package]]
@@ -406,6 +468,12 @@ dependencies = [
 "wasm-bindgen",
 ]

+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
 [[package]]
 name = "libc"
 version = "0.2.153"
@@ -424,6 +492,15 @@ version = "2.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6c8640c5d730cb13ebd907d8d04b52f55ac9a2eec55b440c8892f40d56c76c1d"

+[[package]]
+name = "memoffset"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
+dependencies = [
+ "autocfg",
+]
+
 [[package]]
 name = "miniz_oxide"
 version = "0.7.2"
@@ -460,7 +537,7 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c705f256449c60da65e11ff6626e0c16a0a0b96aaa348de61376b249bc340f41"
 dependencies = [
- "regex",
+ "regex 1.10.4",
 ]

 [[package]]
@@ -530,6 +607,12 @@ version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"

+[[package]]
+name = "portable-atomic"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da544ee218f0d287a911e9c99a39a8c9bc8fcad3cb8db5959940044ecfc67265"
+
 [[package]]
 name = "powerfmt"
 version = "0.2.0"
@@ -544,13 +627,86 @@ checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"

 [[package]]
 name = "proc-macro2"
-version = "1.0.79"
+version = "1.0.86"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e835ff2298f5721608eb1a980ecaee1aef2c132bf95ecc026a11b7bf3c01c02e"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
 dependencies = [
 "unicode-ident",
 ]

+[[package]]
+name = "pyo3"
+version = "0.22.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15ee168e30649f7f234c3d49ef5a7a6cbf5134289bc46c29ff3155fa3221c225"
+dependencies = [
+ "cfg-if",
+ "indoc",
+ "libc",
+ "memoffset",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+ "unindent",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.22.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e61cef80755fe9e46bb8a0b8f20752ca7676dcc07a5277d8b7768c6172e529b3"
+dependencies = [
+ "once_cell",
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.22.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67ce096073ec5405f5ee2b8b31f03a68e02aa10d5d4f565eca04acc41931fa1c"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.22.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2440c6d12bc8f3ae39f1e775266fa5122fd0c8891ce7520fa6048e683ad3de28"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.22.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1be962f0e06da8f8465729ea2cb71a416d2257dff56cbe40a70d3e62a93ae5d1"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "pyo3-build-config",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyroncalc"
+version = "0.1.2"
+dependencies = [
+ "ironcalc",
+ "pyo3",
+ "serde",
+ "serde_json",
+]
+
 [[package]]
 name = "quote"
 version = "1.0.35"
@@ -590,16 +746,29 @@ dependencies = [
 "getrandom",
 ]

+[[package]]
+name = "regex"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9329abc99e39129fcceabd24cf5d85b4671ef7c29c50e972bc5afe32438ec384"
+dependencies = [
+ "aho-corasick 0.6.10",
+ "memchr",
+ "regex-syntax 0.5.6",
+ "thread_local",
+ "utf8-ranges",
+]
+
 [[package]]
 name = "regex"
 version = "1.10.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c117dbdfde9c8308975b6a18d71f3f385c89461f7b3fb054288ecf2a2058ba4c"
 dependencies = [
- "aho-corasick",
+ "aho-corasick 1.1.3",
 "memchr",
 "regex-automata",
- "regex-syntax",
+ "regex-syntax 0.8.3",
 ]

 [[package]]
@@ -608,9 +777,18 @@ version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "86b83b8b9847f9bf95ef68afb0b8e6cdb80f498442f5179a29fad448fcc1eaea"
 dependencies = [
- "aho-corasick",
+ "aho-corasick 1.1.3",
 "memchr",
- "regex-syntax",
+ "regex-syntax 0.8.3",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d707a4fa2637f2dca2ef9fd02225ec7661fe01a53623c1e6515b6916511f7a7"
+dependencies = [
+ "ucd-util",
 ]

 [[package]]
@@ -679,17 +857,6 @@ dependencies = [
 "serde",
 ]

-[[package]]
-name = "serde_repr"
-version = "0.1.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b2e6b945e9d3df726b65d6ee24060aff8e3533d431f677a9695db04eff9dfdb"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "sha1"
 version = "0.10.6"
@@ -726,15 +893,21 @@ checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc"

 [[package]]
 name = "syn"
-version = "2.0.58"
+version = "2.0.77"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44cfb93f38070beee36b3fef7d4f5a16f27751d94b187b666a5cc5e9b0d30687"
+checksum = "9f35bcdf61fd8e7be6caf75f429fdca8beb3ed76584befb503b1569faee373ed"
 dependencies = [
 "proc-macro2",
 "quote",
 "unicode-ident",
 ]

+[[package]]
+name = "target-lexicon"
+version = "0.12.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+
 [[package]]
 name = "thiserror"
 version = "1.0.58"
@@ -755,6 +928,15 @@ dependencies = [
 "syn",
 ]

+[[package]]
+name = "thread_local"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6b53e329000edc2b34dbe8545fd20e55a333362d0a321909685a19bd28c3f1b"
+dependencies = [
+ "lazy_static",
+]
+
 [[package]]
 name = "time"
 version = "0.3.34"
@@ -780,12 +962,30 @@ version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"

+[[package]]
+name = "ucd-util"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "abd2fc5d32b590614af8b0a20d837f32eca055edd0bbead59a9cfe80858be003"
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"

+[[package]]
+name = "unindent"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7de7d73e1754487cb58364ee906a499937a0dfabd86bcb980fa99ec8c8fa2ce"
+
+[[package]]
+name = "utf8-ranges"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fcfc827f90e53a02eaef5e535ee14266c1d569214c6aa70133a624d8a3164ba"
+
 [[package]]
 name = "uuid"
 version = "1.8.0"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -5,6 +5,7 @@ members = [
  "base",
  "xlsx",
  "bindings/wasm",
+  "bindings/python",
 ]

 exclude = [
--- a/30
+++ b/30
@@ -1,49 +1,53 @@
-all:
-	cargo build --release
-	cd bindings/wasm/ && make
-	cd webapp && npm install && npm run build
-
+.PHONY: lint
 lint:
 	cargo fmt -- --check
-	# TODO: See issue #33
-	# cargo clippy --all-targets --all-features -- -D warnings -D clippy::expect_used -D clippy::unwrap_used -D clippy::panic
-	cargo clippy --all-targets --all-features -- -D warnings
+	cargo clippy --all-targets --all-features
+	cd webapp && npm install && npm run check

+.PHONY: format
 format:
 	cargo fmt

+.PHONY: tests
 tests: lint
 	cargo test
 	./target/debug/documentation
 	cmp functions.md wiki/functions.md || exit 1
 	make remove-artifacts
-	cd bindings/wasm/ && make tests
+	# Regretabbly we need to build the wasm twice, once for the nodejs tests
+	# and a second one for the vitest.
+	cd bindings/wasm/ && wasm-pack build --target nodejs && node tests/test.mjs && make
+	cd webapp && npm run test
+	cd bindings/python && ./run_tests.sh && ./run_examples.sh

+.PHONY: remove-artifacts
 remove-artifacts:
 	rm -f xlsx/hello-calc.xlsx
 	rm -f xlsx/hello-styles.xlsx
 	rm -f xlsx/widths-and-heights.xlsx
 	rm -f functions.md

+.PHONY: clean
 clean: remove-artifacts
 	cargo clean
 	rm -r -f base/target
 	rm -r -f xlsx/target
+	rm -r -f bindings/python/target
+	rm -r -f bindings/wasm/targets
 	rm -f cargo-test-*
 	rm -f base/cargo-test-*
 	rm -f xlsx/cargo-test-*
-	rm -r -f webapp/node_modules
-

+.PHONY: coverage
 coverage:
 	CARGO_INCREMENTAL=0 RUSTFLAGS='-C instrument-coverage' LLVM_PROFILE_FILE='cargo-test-%p-%m.profraw' cargo test
 	grcov . --binary-path ./target/debug/deps/ -s . -t html --branch --ignore-not-existing --ignore '../*' --ignore "/*" -o target/coverage/html

+.PHONY: update-docs
 update-docs:
 	cargo build
 	./target/debug/documentation -o wiki/functions.md

+.PHONY: docs
 docs:
 	cargo doc --no-deps
-
-.PHONY: lint format tests docs coverage all
--- a/README.md
+++ b/README.md
@@ -123,12 +123,12 @@ See https://github.com/ironcalc

 An early preview of the technology running entirely in your browser:

-https://playground.ironcalc.com
+https://app.ironcalc.com


 # Collaborators needed!. Call to action

-We don't have a vibrant community just yet. This is the very stages of the project. But if you are passionate about code with high standards and no compromises, if you are looking for a project with high impact, if you are interested in a better, more open infrastructure for spreadsheets, whether you are a developer (rust, python, TypeScript, electron/tauri/anything else native app, React, you name it), a designer (we need a logo desperately!), an Excel power user who wants features, a business looking to integrate a MIT/Apache licensed spreadsheet in your own SaaS application join us!
+We don't have a vibrant community just yet. This is the very stages of the project. But if you are passionate about code with high standards and no compromises, if you are looking for a project with high impact, if you are interested in a better, more open infrastructure for spreadsheets, whether you are a developer (rust, python, TypeScript, electron/tauri/anything else native app, React, you name it), a designer, an Excel power user who wants features, a business looking to integrate a MIT/Apache licensed spreadsheet in your own SaaS application join us!

 The best place to start will be to join or [discord channel](https://discord.gg/zZYWfh3RHJ) or send us an email at hello@ironcalc.com.

--- a/assets/android-chrome-192x192.png
+++ b/assets/android-chrome-192x192.png
--- a/assets/android-chrome-512x512.png
+++ b/assets/android-chrome-512x512.png
--- a/assets/apple-touch-icon.png
+++ b/assets/apple-touch-icon.png
--- a/assets/favicon-16x16.png
+++ b/assets/favicon-16x16.png
--- a/assets/favicon-32x32.png
+++ b/assets/favicon-32x32.png
--- a/assets/favicon.ico
+++ b/assets/favicon.ico
--- a/assets/icon/ironcalc_icon.png
+++ b/assets/icon/ironcalc_icon.png
--- a/assets/icon/ironcalc_icon.svg
+++ b/assets/icon/ironcalc_icon.svg
@@ -0,0 +1,8 @@
+<svg width="600" height="600" viewBox="0 0 600 600" fill="none" xmlns="http://www.w3.org/2000/svg">
+<rect width="600" height="600" rx="20" fill="#F2994A"/>
+<path opacity="0.8" fill-rule="evenodd" clip-rule="evenodd" d="M348.98 100C348.98 166.034 322.748 229.362 276.055 276.055C268.163 283.947 259.796 291.255 251.021 297.95L251.021 500L348.98 500H251.021C251.021 433.966 277.252 370.637 323.945 323.945C331.837 316.053 340.204 308.745 348.98 302.05L348.98 100Z" fill="white"/>
+<path opacity="0.8" fill-rule="evenodd" clip-rule="evenodd" d="M251.021 100.068C251.003 140.096 235.094 178.481 206.788 206.787C178.466 235.109 140.053 251.02 100 251.02V348.979C154.873 348.979 207.877 330.866 251.021 297.95V100.068Z" fill="white"/>
+<path opacity="0.8" fill-rule="evenodd" clip-rule="evenodd" d="M348.98 499.882C349.011 459.872 364.918 421.507 393.213 393.213C421.534 364.891 459.947 348.98 500 348.98V251.02C445.128 251.02 392.123 269.134 348.98 302.05V499.882Z" fill="white"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M276.055 276.055C322.748 229.362 348.98 166.034 348.98 100H251.021V297.95C259.796 291.255 268.163 283.947 276.055 276.055Z" fill="white"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M348.98 302.05V499.895C348.98 499.93 348.98 499.965 348.98 500L251.021 500C251.021 499.946 251.02 499.891 251.021 499.837C251.064 433.862 277.291 370.599 323.945 323.945C331.837 316.053 340.204 308.745 348.98 302.05Z" fill="white"/>
+</svg>
--- a/assets/logo.png
+++ b/assets/logo.png
--- a/assets/logo/png/black.png
+++ b/assets/logo/png/black.png
--- a/assets/logo/png/orange+black.png
+++ b/assets/logo/png/orange+black.png
--- a/assets/logo/png/orange+white.png
+++ b/assets/logo/png/orange+white.png
--- a/assets/logo/png/white.png
+++ b/assets/logo/png/white.png
--- a/assets/logo/svg/black.svg
+++ b/assets/logo/svg/black.svg
--- a/assets/logo/svg/orange+black.svg
+++ b/assets/logo/svg/orange+black.svg
--- a/assets/logo/svg/orange+white.svg
+++ b/assets/logo/svg/orange+white.svg
--- a/assets/logo/svg/white.svg
+++ b/assets/logo/svg/white.svg
--- a/base/Cargo.toml
+++ b/base/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ironcalc_base"
-version = "0.1.3"
+version = "0.2.0"
 authors = ["Nicolás Hatcher <nicolas@theuniverse.today>"]
 edition = "2021"
 homepage = "https://www.ironcalc.com"
@@ -12,14 +12,17 @@ readme = "README.md"

 [dependencies]
 serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-serde_repr = "0.1"
 ryu = "1.0"
 chrono = "0.4"
 chrono-tz = "0.9"
 regex = "1.0"
 once_cell = "1.16.0"
 bitcode = "0.6.0"
+csv = "1.3.0"
+csv-sniffer = "0.1"
+
+[dev-dependencies]
+serde_json = "1.0"

 [target.'cfg(target_arch = "wasm32")'.dependencies]
 js-sys = { version = "0.3.69" }
--- a/base/examples/formulas_and_errors.rs
+++ b/base/examples/formulas_and_errors.rs
@@ -3,15 +3,15 @@ use ironcalc_base::{types::CellType, Model};
 fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut model = Model::new_empty("formulas-and-errors", "en", "UTC")?;
    // A1
-    model.set_user_input(0, 1, 1, "1".to_string());
+    model.set_user_input(0, 1, 1, "1".to_string())?;
    // A2
-    model.set_user_input(0, 2, 1, "2".to_string());
+    model.set_user_input(0, 2, 1, "2".to_string())?;
    // A3
-    model.set_user_input(0, 3, 1, "3".to_string());
+    model.set_user_input(0, 3, 1, "3".to_string())?;
    // B1
-    model.set_user_input(0, 1, 2, "=SUM(A1:A3)".to_string());
+    model.set_user_input(0, 1, 2, "=SUM(A1:A3)".to_string())?;
    // B2
-    model.set_user_input(0, 2, 2, "=B1/0".to_string());
+    model.set_user_input(0, 2, 2, "=B1/0".to_string())?;
    // Evaluate
    model.evaluate();

--- a/base/examples/hello_world.rs
+++ b/base/examples/hello_world.rs
@@ -3,11 +3,11 @@ use ironcalc_base::{cell::CellValue, Model};
 fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut model = Model::new_empty("hello-world", "en", "UTC")?;
    // A1
-    model.set_user_input(0, 1, 1, "Hello".to_string());
+    model.set_user_input(0, 1, 1, "Hello".to_string())?;
    // B1
-    model.set_user_input(0, 1, 2, "world!".to_string());
+    model.set_user_input(0, 1, 2, "world!".to_string())?;
    // C1
-    model.set_user_input(0, 1, 3, "=CONCAT(A1, \" \", B1".to_string());
+    model.set_user_input(0, 1, 3, "=CONCAT(A1, \" \", B1".to_string())?;
    // evaluates
    model.evaluate();

--- a/base/src/actions.rs
+++ b/base/src/actions.rs
@@ -79,12 +79,11 @@ impl Model {
        let formula_or_value = self
            .get_cell_formula(sheet, source_row, source_column)?
            .unwrap_or_else(|| source_cell.get_text(&self.workbook.shared_strings, &self.language));
-        self.set_user_input(sheet, target_row, target_column, formula_or_value);
+        self.set_user_input(sheet, target_row, target_column, formula_or_value)?;
        self.workbook
            .worksheet_mut(sheet)?
-            .set_cell_style(target_row, target_column, style);
-        self.cell_clear_all(sheet, source_row, source_column)?;
-        Ok(())
+            .set_cell_style(target_row, target_column, style)?;
+        self.cell_clear_all(sheet, source_row, source_column)
    }

    /// Inserts one or more new columns into the model at the specified index.
--- a/base/src/cell.rs
+++ b/base/src/cell.rs
@@ -1,12 +1,9 @@
 use crate::{
    expressions::token::Error, language::Language, number_format::to_excel_precision_str, types::*,
 };
-use serde::{Deserialize, Serialize};
-use serde_json::json;

 /// A CellValue is the representation of the cell content.
-#[derive(Serialize, Deserialize, Debug, PartialEq)]
-#[serde(untagged)]
+#[derive(Debug, PartialEq)]
 pub enum CellValue {
    None,
    String(String),
@@ -14,17 +11,6 @@ pub enum CellValue {
    Boolean(bool),
 }

-impl CellValue {
-    pub fn to_json_str(&self) -> String {
-        match &self {
-            CellValue::None => "null".to_string(),
-            CellValue::String(s) => json!(s).to_string(),
-            CellValue::Number(f) => json!(f).to_string(),
-            CellValue::Boolean(b) => json!(b).to_string(),
-        }
-    }
-}
-
 impl From<f64> for CellValue {
    fn from(value: f64) -> Self {
        Self::Number(value)
--- a/base/src/constants.rs
+++ b/base/src/constants.rs
@@ -2,10 +2,12 @@
 /// COLUMN_WIDTH and ROW_HEIGHT are pixel values
 /// A column width of Excel value `w` will result in `w * COLUMN_WIDTH_FACTOR` pixels
 /// Note that these constants are inlined
-pub(crate) const DEFAULT_COLUMN_WIDTH: f64 = 100.0;
-pub(crate) const DEFAULT_ROW_HEIGHT: f64 = 21.0;
+pub(crate) const DEFAULT_COLUMN_WIDTH: f64 = 125.0;
+pub(crate) const DEFAULT_ROW_HEIGHT: f64 = 28.0;
 pub(crate) const COLUMN_WIDTH_FACTOR: f64 = 12.0;
 pub(crate) const ROW_HEIGHT_FACTOR: f64 = 2.0;
+pub(crate) const DEFAULT_WINDOW_HEIGH: i64 = 600;
+pub(crate) const DEFAULT_WINDOW_WIDTH: i64 = 800;

 pub(crate) const LAST_COLUMN: i32 = 16_384;
 pub(crate) const LAST_ROW: i32 = 1_048_576;
--- a/base/src/expressions/parser/mod.rs
+++ b/base/src/expressions/parser/mod.rs
@@ -222,7 +222,7 @@ impl Parser {

    pub fn parse(&mut self, formula: &str, context: &Option<CellReferenceRC>) -> Node {
        self.lexer.set_formula(formula);
-        self.context = context.clone();
+        self.context.clone_from(context);
        self.parse_expr()
    }

--- a/base/src/expressions/token.rs
+++ b/base/src/expressions/token.rs
@@ -2,7 +2,6 @@ use std::fmt;

 use bitcode::{Decode, Encode};
 use serde::{Deserialize, Serialize};
-use serde_repr::{Deserialize_repr, Serialize_repr};

 use crate::language::Language;

@@ -81,8 +80,7 @@ impl fmt::Display for OpProduct {
 ///  * "#ERROR!" means there was an error processing the formula (for instance "=A1+")
 ///  * "#N/IMPL!" means the formula or feature in Excel but has not been implemented in IronCalc
 /// Note that they are serialized/deserialized by index
-#[derive(Serialize_repr, Deserialize_repr, Encode, Decode, Debug, PartialEq, Eq, Clone)]
-#[repr(u8)]
+#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
 pub enum Error {
    REF,
    NAME,
--- a/base/src/language/language.bin
+++ b/base/src/language/language.bin
@@ -0,0 +1 @@
+PfrendeesD<>VRAITRUEWAHRVERDADEROTVFAUXFALSEFALSCHFALSOUw#REF!#REF!#BEZUG!#¡REF!e<>#NOM?#NAME?#NAME?#¿NOMBRE?x<>#VALEUR!#VALUE!#WERT!#¡VALOR!w<>#DIV/0!#DIV/0!#DIV/0!#¡DIV/0!<04>#N/A#N/A#NV#N/AXv#NOMBRE!#NUM!#ZAHL!#¡NUM!<02><>#N/IMPL!#N/IMPL!#N/IMPL!#N/IMPL!w{#SPILL!#SPILL!#ÜBERLAUF!#SPILL!ff#CALC!#CALC!#CALC!#CALC!ff#CIRC!#CIRC!#CIRC!#CIRC!ww#ERROR!#ERROR!#ERROR!#ERROR!ff#NULL!#NULL!#NULL!#NULL!
--- a/base/src/language/mod.rs
+++ b/base/src/language/mod.rs
@@ -1,15 +1,15 @@
-use once_cell::sync::Lazy;
-use serde::{Deserialize, Serialize};
-
 use std::collections::HashMap;

-#[derive(Serialize, Deserialize, Clone)]
+use bitcode::{Decode, Encode};
+use once_cell::sync::Lazy;
+
+#[derive(Encode, Decode, Clone)]
 pub struct Booleans {
    pub r#true: String,
    pub r#false: String,
 }

-#[derive(Serialize, Deserialize, Clone)]
+#[derive(Encode, Decode, Clone)]
 pub struct Errors {
    pub r#ref: String,
    pub name: String,
@@ -25,14 +25,14 @@ pub struct Errors {
    pub null: String,
 }

-#[derive(Serialize, Deserialize, Clone)]
+#[derive(Encode, Decode, Clone)]
 pub struct Language {
    pub booleans: Booleans,
    pub errors: Errors,
 }

 static LANGUAGES: Lazy<HashMap<String, Language>> = Lazy::new(|| {
-    serde_json::from_str(include_str!("language.json")).expect("Failed parsing language file")
+    bitcode::decode(include_bytes!("language.bin")).expect("Failed parsing language file")
 });

 pub fn get_language(id: &str) -> Result<&Language, String> {
--- a/base/src/lib.rs
+++ b/base/src/lib.rs
@@ -57,4 +57,6 @@ pub mod mock_time;

 pub use model::get_milliseconds_since_epoch;
 pub use model::Model;
+pub use user_model::BorderArea;
+pub use user_model::ClipboardData;
 pub use user_model::UserModel;
--- a/base/src/locale/locales.bin
+++ b/base/src/locale/locales.bin
--- a/base/src/locale/mod.rs
+++ b/base/src/locale/mod.rs
@@ -1,32 +1,29 @@
+use bitcode::{Decode, Encode};
 use once_cell::sync::Lazy;
-use serde::{Deserialize, Serialize};

 use std::collections::HashMap;

-#[derive(Serialize, Deserialize, Clone)]
+#[derive(Encode, Decode, Clone)]
 pub struct Locale {
    pub dates: Dates,
    pub numbers: NumbersProperties,
    pub currency: Currency,
 }

-#[derive(Serialize, Deserialize, Clone)]
+#[derive(Encode, Decode, Clone)]
 pub struct Currency {
    pub iso: String,
    pub symbol: String,
 }

-#[derive(Serialize, Deserialize, Clone)]
+#[derive(Encode, Decode, Clone)]
 pub struct NumbersProperties {
-    #[serde(rename = "symbols-numberSystem-latn")]
    pub symbols: NumbersSymbols,
-    #[serde(rename = "decimalFormats-numberSystem-latn")]
    pub decimal_formats: DecimalFormats,
-    #[serde(rename = "currencyFormats-numberSystem-latn")]
    pub currency_formats: CurrencyFormats,
 }

-#[derive(Serialize, Deserialize, Clone)]
+#[derive(Encode, Decode, Clone)]
 pub struct Dates {
    pub day_names: Vec<String>,
    pub day_names_short: Vec<String>,
@@ -35,8 +32,7 @@ pub struct Dates {
    pub months_letter: Vec<String>,
 }

-#[derive(Serialize, Deserialize, Clone)]
-#[serde(rename_all = "camelCase")]
+#[derive(Encode, Decode, Clone)]
 pub struct NumbersSymbols {
    pub decimal: String,
    pub group: String,
@@ -54,31 +50,23 @@ pub struct NumbersSymbols {
 }

 // See: https://cldr.unicode.org/translation/number-currency-formats/number-and-currency-patterns
-#[derive(Serialize, Deserialize, Clone)]
+#[derive(Encode, Decode, Clone)]
 pub struct CurrencyFormats {
    pub standard: String,
-    #[serde(rename = "standard-alphaNextToNumber")]
-    #[serde(skip_serializing_if = "Option::is_none")]
    pub standard_alpha_next_to_number: Option<String>,
-    #[serde(rename = "standard-noCurrency")]
    pub standard_no_currency: String,
    pub accounting: String,
-    #[serde(rename = "accounting-alphaNextToNumber")]
-    #[serde(skip_serializing_if = "Option::is_none")]
    pub accounting_alpha_next_to_number: Option<String>,
-    #[serde(rename = "accounting-noCurrency")]
    pub accounting_no_currency: String,
 }

-#[derive(Serialize, Deserialize, Clone)]
-#[serde(rename_all = "camelCase")]
+#[derive(Encode, Decode, Clone)]
 pub struct DecimalFormats {
    pub standard: String,
 }

-static LOCALES: Lazy<HashMap<String, Locale>> = Lazy::new(|| {
-    serde_json::from_str(include_str!("locales.json")).expect("Failed parsing locale")
-});
+static LOCALES: Lazy<HashMap<String, Locale>> =
+    Lazy::new(|| bitcode::decode(include_bytes!("locales.bin")).expect("Failed parsing locale"));

 pub fn get_locale(id: &str) -> Result<&Locale, String> {
    // TODO: pass the locale once we implement locales in Rust
--- a/base/src/model.rs
+++ b/base/src/model.rs
@@ -7,19 +7,15 @@ use crate::{
    calc_result::{CalcResult, Range},
    cell::CellValue,
    constants::{self, LAST_COLUMN, LAST_ROW},
-    expressions::token::{Error, OpCompare, OpProduct, OpSum, OpUnary},
-    expressions::{
-        parser::move_formula::{move_formula, MoveContext},
-        token::get_error_by_name,
-        types::*,
-        utils::{self, is_valid_row},
-    },
    expressions::{
        parser::{
+            move_formula::{move_formula, MoveContext},
            stringify::{to_rc_format, to_string},
            Node, Parser,
        },
-        utils::is_valid_column_number,
+        token::{get_error_by_name, Error, OpCompare, OpProduct, OpSum, OpUnary},
+        types::*,
+        utils::{self, is_valid_column_number, is_valid_row},
    },
    formatter::{
        format::{format_number, parse_formatted_number},
@@ -118,6 +114,8 @@ pub struct Model {
    pub(crate) language: Language,
    /// The timezone used to evaluate the model
    pub(crate) tz: Tz,
+    /// The view id. A view consist of a selected sheet and ranges.
+    pub(crate) view_id: u32,
 }

 // FIXME: Maybe this should be the same as CellReference
@@ -681,6 +679,13 @@ impl Model {
        Err(format!("Invalid color: {}", color))
    }

+    /// Makes the grid lines in the sheet visible (`true`) or hidden (`false`)
+    pub fn set_show_grid_lines(&mut self, sheet: u32, show_grid_lines: bool) -> Result<(), String> {
+        let worksheet = self.workbook.worksheet_mut(sheet)?;
+        worksheet.show_grid_lines = show_grid_lines;
+        Ok(())
+    }
+
    fn get_cell_value(&self, cell: &Cell, cell_reference: CellReferenceIndex) -> CalcResult {
        use Cell::*;
        match cell {
@@ -886,6 +891,7 @@ impl Model {
            language,
            locale,
            tz,
+            view_id: 0,
        };

        model.parse_formulas();
@@ -1194,10 +1200,10 @@ impl Model {
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let mut model = Model::new_empty("model", "en", "UTC")?;
    /// let (sheet, row, column) = (0, 1, 1);
-    /// model.set_user_input(sheet, row, column, "Hello!".to_string());
+    /// model.set_user_input(sheet, row, column, "Hello!".to_string())?;
    /// assert_eq!(model.get_cell_content(sheet, row, column)?, "Hello!".to_string());
    ///
-    /// model.update_cell_with_text(sheet, row, column, "Goodbye!");
+    /// model.update_cell_with_text(sheet, row, column, "Goodbye!")?;
    /// assert_eq!(model.get_cell_content(sheet, row, column)?, "Goodbye!".to_string());
    /// # Ok(())
    /// # }
@@ -1208,23 +1214,30 @@ impl Model {
    /// * [Model::update_cell_with_number()]
    /// * [Model::update_cell_with_bool()]
    /// * [Model::update_cell_with_formula()]
-    pub fn update_cell_with_text(&mut self, sheet: u32, row: i32, column: i32, value: &str) {
-        let style_index = self.get_cell_style_index(sheet, row, column);
+    pub fn update_cell_with_text(
+        &mut self,
+        sheet: u32,
+        row: i32,
+        column: i32,
+        value: &str,
+    ) -> Result<(), String> {
+        let style_index = self.get_cell_style_index(sheet, row, column)?;
        let new_style_index;
        if common::value_needs_quoting(value, &self.language) {
            new_style_index = self
                .workbook
                .styles
-                .get_style_with_quote_prefix(style_index);
+                .get_style_with_quote_prefix(style_index)?;
        } else if self.workbook.styles.style_is_quote_prefix(style_index) {
            new_style_index = self
                .workbook
                .styles
-                .get_style_without_quote_prefix(style_index);
+                .get_style_without_quote_prefix(style_index)?;
        } else {
            new_style_index = style_index;
        }
-        self.set_cell_with_string(sheet, row, column, value, new_style_index);
+
+        self.set_cell_with_string(sheet, row, column, value, new_style_index)
    }

    /// Updates the value of a cell with a boolean value
@@ -1237,10 +1250,10 @@ impl Model {
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let mut model = Model::new_empty("model", "en", "UTC")?;
    /// let (sheet, row, column) = (0, 1, 1);
-    /// model.set_user_input(sheet, row, column, "TRUE".to_string());
+    /// model.set_user_input(sheet, row, column, "TRUE".to_string())?;
    /// assert_eq!(model.get_cell_content(sheet, row, column)?, "TRUE".to_string());
    ///
-    /// model.update_cell_with_bool(sheet, row, column, false);
+    /// model.update_cell_with_bool(sheet, row, column, false)?;
    /// assert_eq!(model.get_cell_content(sheet, row, column)?, "FALSE".to_string());
    /// # Ok(())
    /// # }
@@ -1251,17 +1264,22 @@ impl Model {
    /// * [Model::update_cell_with_number()]
    /// * [Model::update_cell_with_text()]
    /// * [Model::update_cell_with_formula()]
-    pub fn update_cell_with_bool(&mut self, sheet: u32, row: i32, column: i32, value: bool) {
-        let style_index = self.get_cell_style_index(sheet, row, column);
+    pub fn update_cell_with_bool(
+        &mut self,
+        sheet: u32,
+        row: i32,
+        column: i32,
+        value: bool,
+    ) -> Result<(), String> {
+        let style_index = self.get_cell_style_index(sheet, row, column)?;
        let new_style_index = if self.workbook.styles.style_is_quote_prefix(style_index) {
            self.workbook
                .styles
-                .get_style_without_quote_prefix(style_index)
+                .get_style_without_quote_prefix(style_index)?
        } else {
            style_index
        };
-        let worksheet = &mut self.workbook.worksheets[sheet as usize];
-        worksheet.set_cell_with_boolean(row, column, value, new_style_index);
+        self.set_cell_with_boolean(sheet, row, column, value, new_style_index)
    }

    /// Updates the value of a cell with a number
@@ -1274,10 +1292,10 @@ impl Model {
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let mut model = Model::new_empty("model", "en", "UTC")?;
    /// let (sheet, row, column) = (0, 1, 1);
-    /// model.set_user_input(sheet, row, column, "42".to_string());
+    /// model.set_user_input(sheet, row, column, "42".to_string())?;
    /// assert_eq!(model.get_cell_content(sheet, row, column)?, "42".to_string());
    ///
-    /// model.update_cell_with_number(sheet, row, column, 23.0);
+    /// model.update_cell_with_number(sheet, row, column, 23.0)?;
    /// assert_eq!(model.get_cell_content(sheet, row, column)?, "23".to_string());
    /// # Ok(())
    /// # }
@@ -1288,17 +1306,22 @@ impl Model {
    /// * [Model::update_cell_with_text()]
    /// * [Model::update_cell_with_bool()]
    /// * [Model::update_cell_with_formula()]
-    pub fn update_cell_with_number(&mut self, sheet: u32, row: i32, column: i32, value: f64) {
-        let style_index = self.get_cell_style_index(sheet, row, column);
+    pub fn update_cell_with_number(
+        &mut self,
+        sheet: u32,
+        row: i32,
+        column: i32,
+        value: f64,
+    ) -> Result<(), String> {
+        let style_index = self.get_cell_style_index(sheet, row, column)?;
        let new_style_index = if self.workbook.styles.style_is_quote_prefix(style_index) {
            self.workbook
                .styles
-                .get_style_without_quote_prefix(style_index)
+                .get_style_without_quote_prefix(style_index)?
        } else {
            style_index
        };
-        let worksheet = &mut self.workbook.worksheets[sheet as usize];
-        worksheet.set_cell_with_number(row, column, value, new_style_index);
+        self.set_cell_with_number(sheet, row, column, value, new_style_index)
    }

    /// Updates the formula of given cell
@@ -1312,11 +1335,11 @@ impl Model {
    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
    /// let mut model = Model::new_empty("model", "en", "UTC")?;
    /// let (sheet, row, column) = (0, 1, 1);
-    /// model.set_user_input(sheet, row, column, "=A2*2".to_string());
+    /// model.set_user_input(sheet, row, column, "=A2*2".to_string())?;
    /// model.evaluate();
    /// assert_eq!(model.get_cell_content(sheet, row, column)?, "=A2*2".to_string());
    ///
-    /// model.update_cell_with_formula(sheet, row, column, "=A3*2".to_string());
+    /// model.update_cell_with_formula(sheet, row, column, "=A3*2".to_string())?;
    /// model.evaluate();
    /// assert_eq!(model.get_cell_content(sheet, row, column)?, "=A3*2".to_string());
    /// # Ok(())
@@ -1335,12 +1358,12 @@ impl Model {
        column: i32,
        formula: String,
    ) -> Result<(), String> {
-        let mut style_index = self.get_cell_style_index(sheet, row, column);
+        let mut style_index = self.get_cell_style_index(sheet, row, column)?;
        if self.workbook.styles.style_is_quote_prefix(style_index) {
            style_index = self
                .workbook
                .styles
-                .get_style_without_quote_prefix(style_index);
+                .get_style_without_quote_prefix(style_index)?;
        }
        let formula = formula
            .strip_prefix('=')
@@ -1380,31 +1403,36 @@ impl Model {
    /// * [Model::update_cell_with_number()]
    /// * [Model::update_cell_with_bool()]
    /// * [Model::update_cell_with_text()]
-    pub fn set_user_input(&mut self, sheet: u32, row: i32, column: i32, value: String) {
+    pub fn set_user_input(
+        &mut self,
+        sheet: u32,
+        row: i32,
+        column: i32,
+        value: String,
+    ) -> Result<(), String> {
        // If value starts with "'" then we force the style to be quote_prefix
-        let style_index = self.get_cell_style_index(sheet, row, column);
+        let style_index = self.get_cell_style_index(sheet, row, column)?;
        if let Some(new_value) = value.strip_prefix('\'') {
            // First check if it needs quoting
            let new_style = if common::value_needs_quoting(new_value, &self.language) {
                self.workbook
                    .styles
-                    .get_style_with_quote_prefix(style_index)
+                    .get_style_with_quote_prefix(style_index)?
            } else {
                style_index
            };
-            self.set_cell_with_string(sheet, row, column, new_value, new_style);
+            self.set_cell_with_string(sheet, row, column, new_value, new_style)?;
        } else {
            let mut new_style_index = style_index;
            if self.workbook.styles.style_is_quote_prefix(style_index) {
                new_style_index = self
                    .workbook
                    .styles
-                    .get_style_without_quote_prefix(style_index);
+                    .get_style_without_quote_prefix(style_index)?;
            }
            if let Some(formula) = value.strip_prefix('=') {
-                let formula_index = self
-                    .set_cell_with_formula(sheet, row, column, formula, new_style_index)
-                    .expect("could not set the cell formula");
+                let formula_index =
+                    self.set_cell_with_formula(sheet, row, column, formula, new_style_index)?;
                // Update the style if needed
                let cell = CellReferenceIndex { sheet, row, column };
                let parsed_formula = &self.parsed_formulas[sheet as usize][formula_index as usize];
@@ -1412,15 +1440,11 @@ impl Model {
                    let new_style_index = self
                        .workbook
                        .styles
-                        .get_style_with_format(new_style_index, &units.get_num_fmt());
-                    let style = self.workbook.styles.get_style(new_style_index);
-                    self.set_cell_style(sheet, row, column, &style)
-                        .expect("Failed setting the style");
+                        .get_style_with_format(new_style_index, &units.get_num_fmt())?;
+                    let style = self.workbook.styles.get_style(new_style_index)?;
+                    self.set_cell_style(sheet, row, column, &style)?
                }
            } else {
-                let worksheets = &mut self.workbook.worksheets;
-                let worksheet = &mut worksheets[sheet as usize];
-
                // The list of currencies is '$', '€' and the local currency
                let mut currencies = vec!["$", "€"];
                let currency = &self.locale.currency.symbol;
@@ -1433,35 +1457,39 @@ impl Model {
                        // Should not apply the format in the following cases:
                        // - we assign a date to already date-formatted cell
                        let should_apply_format = !(is_likely_date_number_format(
-                            &self.workbook.styles.get_style(new_style_index).num_fmt,
+                            &self.workbook.styles.get_style(new_style_index)?.num_fmt,
                        ) && is_likely_date_number_format(&num_fmt));
                        if should_apply_format {
                            new_style_index = self
                                .workbook
                                .styles
-                                .get_style_with_format(new_style_index, &num_fmt);
+                                .get_style_with_format(new_style_index, &num_fmt)?;
                        }
                    }
-                    worksheet.set_cell_with_number(row, column, v, new_style_index);
-                    return;
+                    let worksheet = self.workbook.worksheet_mut(sheet)?;
+                    worksheet.set_cell_with_number(row, column, v, new_style_index)?;
+                    return Ok(());
                }
                // We try to parse as boolean
                if let Ok(v) = value.to_lowercase().parse::<bool>() {
-                    worksheet.set_cell_with_boolean(row, column, v, new_style_index);
-                    return;
+                    let worksheet = self.workbook.worksheet_mut(sheet)?;
+                    worksheet.set_cell_with_boolean(row, column, v, new_style_index)?;
+                    return Ok(());
                }
                // Check is it is error value
                let upper = value.to_uppercase();
+                let worksheet = self.workbook.worksheet_mut(sheet)?;
                match get_error_by_name(&upper, &self.language) {
                    Some(error) => {
-                        worksheet.set_cell_with_error(row, column, error, new_style_index);
+                        worksheet.set_cell_with_error(row, column, error, new_style_index)?;
                    }
                    None => {
-                        self.set_cell_with_string(sheet, row, column, &value, new_style_index);
+                        self.set_cell_with_string(sheet, row, column, &value, new_style_index)?;
                    }
                }
            }
        }
+        Ok(())
    }

    fn set_cell_with_formula(
@@ -1502,24 +1530,66 @@ impl Model {
            self.parsed_formulas[sheet as usize].push(parsed_formula);
            formula_index = (shared_formulas.len() as i32) - 1;
        }
-        worksheet.set_cell_with_formula(row, column, formula_index, style);
+        worksheet.set_cell_with_formula(row, column, formula_index, style)?;
        Ok(formula_index)
    }

-    fn set_cell_with_string(&mut self, sheet: u32, row: i32, column: i32, value: &str, style: i32) {
-        let worksheets = &mut self.workbook.worksheets;
-        let worksheet = &mut worksheets[sheet as usize];
+    fn set_cell_with_string(
+        &mut self,
+        sheet: u32,
+        row: i32,
+        column: i32,
+        value: &str,
+        style: i32,
+    ) -> Result<(), String> {
        match self.shared_strings.get(value) {
            Some(string_index) => {
-                worksheet.set_cell_with_string(row, column, *string_index as i32, style);
+                self.workbook.worksheet_mut(sheet)?.set_cell_with_string(
+                    row,
+                    column,
+                    *string_index as i32,
+                    style,
+                )?;
            }
            None => {
                let string_index = self.workbook.shared_strings.len();
                self.workbook.shared_strings.push(value.to_string());
                self.shared_strings.insert(value.to_string(), string_index);
-                worksheet.set_cell_with_string(row, column, string_index as i32, style);
+                self.workbook.worksheet_mut(sheet)?.set_cell_with_string(
+                    row,
+                    column,
+                    string_index as i32,
+                    style,
+                )?;
            }
        }
+        Ok(())
+    }
+
+    fn set_cell_with_boolean(
+        &mut self,
+        sheet: u32,
+        row: i32,
+        column: i32,
+        value: bool,
+        style: i32,
+    ) -> Result<(), String> {
+        self.workbook
+            .worksheet_mut(sheet)?
+            .set_cell_with_boolean(row, column, value, style)
+    }
+
+    fn set_cell_with_number(
+        &mut self,
+        sheet: u32,
+        row: i32,
+        column: i32,
+        value: f64,
+        style: i32,
+    ) -> Result<(), String> {
+        self.workbook
+            .worksheet_mut(sheet)?
+            .set_cell_with_number(row, column, value, style)
    }

    /// Gets the Excel Value (Bool, Number, String) of a cell
@@ -1586,7 +1656,7 @@ impl Model {
    ) -> Result<String, String> {
        match self.workbook.worksheet(sheet_index)?.cell(row, column) {
            Some(cell) => {
-                let format = self.get_style_for_cell(sheet_index, row, column).num_fmt;
+                let format = self.get_style_for_cell(sheet_index, row, column)?.num_fmt;
                let formatted_value =
                    cell.formatted_value(&self.workbook.shared_strings, &self.language, |value| {
                        format_number(value, &format, &self.locale).text
@@ -1689,7 +1759,7 @@ impl Model {
    pub fn cell_clear_contents(&mut self, sheet: u32, row: i32, column: i32) -> Result<(), String> {
        self.workbook
            .worksheet_mut(sheet)?
-            .cell_clear_contents(row, column);
+            .cell_clear_contents(row, column)?;
        Ok(())
    }

@@ -1724,43 +1794,40 @@ impl Model {
    }

    /// Returns the style index for cell (`sheet`, `row`, `column`)
-    pub fn get_cell_style_index(&self, sheet: u32, row: i32, column: i32) -> i32 {
+    pub fn get_cell_style_index(&self, sheet: u32, row: i32, column: i32) -> Result<i32, String> {
        // First check the cell, then row, the column
-        let cell = self
-            .workbook
-            .worksheet(sheet)
-            .expect("Invalid sheet")
-            .cell(row, column);
+        let cell = self.workbook.worksheet(sheet)?.cell(row, column);
+
        match cell {
-            Some(cell) => cell.get_style(),
+            Some(cell) => Ok(cell.get_style()),
            None => {
-                let rows = &self.workbook.worksheets[sheet as usize].rows;
+                let rows = &self.workbook.worksheet(sheet)?.rows;
                for r in rows {
                    if r.r == row {
                        if r.custom_format {
-                            return r.s;
+                            return Ok(r.s);
                        }
                        break;
                    }
                }
-                let cols = &self.workbook.worksheets[sheet as usize].cols;
+                let cols = &self.workbook.worksheet(sheet)?.cols;
                for c in cols.iter() {
                    let min = c.min;
                    let max = c.max;
                    if column >= min && column <= max {
-                        return c.style.unwrap_or(0);
+                        return Ok(c.style.unwrap_or(0));
                    }
                }
-                0
+                Ok(0)
            }
        }
    }

    /// Returns the style for cell (`sheet`, `row`, `column`)
-    pub fn get_style_for_cell(&self, sheet: u32, row: i32, column: i32) -> Style {
-        self.workbook
-            .styles
-            .get_style(self.get_cell_style_index(sheet, row, column))
+    pub fn get_style_for_cell(&self, sheet: u32, row: i32, column: i32) -> Result<Style, String> {
+        let style_index = self.get_cell_style_index(sheet, row, column)?;
+        let style = self.workbook.styles.get_style(style_index)?;
+        Ok(style)
    }

    /// Returns an internal binary representation of the workbook
@@ -1800,7 +1867,7 @@ impl Model {
                    Some(formula) => formula,
                    None => self.get_formatted_cell_value(sheet, row, column)?,
                };
-                let style = self.get_style_for_cell(sheet, row, column);
+                let style = self.get_style_for_cell(sheet, row, column)?;
                if style.font.b {
                    cell_markup = format!("**{cell_markup}**")
                }
--- a/base/src/new_empty.rs
+++ b/base/src/new_empty.rs
@@ -4,16 +4,21 @@ use std::collections::HashMap;

 use crate::{
    calc_result::Range,
+    constants::{DEFAULT_WINDOW_HEIGH, DEFAULT_WINDOW_WIDTH},
    expressions::{
        lexer::LexerMode,
-        parser::stringify::{rename_sheet_in_node, to_rc_format},
-        parser::Parser,
+        parser::{
+            stringify::{rename_sheet_in_node, to_rc_format},
+            Parser,
+        },
        types::CellReferenceRC,
    },
    language::get_language,
    locale::get_locale,
    model::{get_milliseconds_since_epoch, Model, ParsedDefinedName},
-    types::{Metadata, SheetState, Workbook, WorkbookSettings, Worksheet},
+    types::{
+        Metadata, SheetState, Workbook, WorkbookSettings, WorkbookView, Worksheet, WorksheetView,
+    },
    utils::ParsedReference,
 };

@@ -33,7 +38,20 @@ fn is_valid_sheet_name(name: &str) -> bool {

 impl Model {
    /// Creates a new worksheet. Note that it does not check if the name or the sheet_id exists
-    fn new_empty_worksheet(name: &str, sheet_id: u32) -> Worksheet {
+    fn new_empty_worksheet(name: &str, sheet_id: u32, view_ids: &[&u32]) -> Worksheet {
+        let mut views = HashMap::new();
+        for id in view_ids {
+            views.insert(
+                **id,
+                WorksheetView {
+                    row: 1,
+                    column: 1,
+                    range: [1, 1, 1, 1],
+                    top_row: 1,
+                    left_column: 1,
+                },
+            );
+        }
        Worksheet {
            cols: vec![],
            rows: vec![],
@@ -48,6 +66,8 @@ impl Model {
            color: Default::default(),
            frozen_columns: 0,
            frozen_rows: 0,
+            show_grid_lines: true,
+            views,
        }
    }

@@ -122,7 +142,7 @@ impl Model {
        self.parsed_defined_names = parsed_defined_names;
    }

-    // Reparses all formulas and defined names
+    /// Reparses all formulas and defined names
    pub(crate) fn reset_parsed_structures(&mut self) {
        self.parser
            .set_worksheets(self.workbook.get_worksheet_names());
@@ -153,7 +173,8 @@ impl Model {
        let sheet_name = format!("{}{}", base_name, index);
        // Now we need a sheet_id
        let sheet_id = self.get_new_sheet_id();
-        let worksheet = Model::new_empty_worksheet(&sheet_name, sheet_id);
+        let view_ids: Vec<&u32> = self.workbook.views.keys().collect();
+        let worksheet = Model::new_empty_worksheet(&sheet_name, sheet_id, &view_ids);
        self.workbook.worksheets.push(worksheet);
        self.reset_parsed_structures();
        (sheet_name, self.workbook.worksheets.len() as u32 - 1)
@@ -184,7 +205,8 @@ impl Model {
            Some(id) => id,
            None => self.get_new_sheet_id(),
        };
-        let worksheet = Model::new_empty_worksheet(sheet_name, sheet_id);
+        let view_ids: Vec<&u32> = self.workbook.views.keys().collect();
+        let worksheet = Model::new_empty_worksheet(sheet_name, sheet_id, &view_ids);
        if sheet_index as usize > self.workbook.worksheets.len() {
            return Err("Sheet index out of range".to_string());
        }
@@ -331,11 +353,21 @@ impl Model {
        // "2020-08-06T21:20:53Z
        let now = dt.format("%Y-%m-%dT%H:%M:%SZ").to_string();

+        let mut views = HashMap::new();
+        views.insert(
+            0,
+            WorkbookView {
+                sheet: 0,
+                window_width: DEFAULT_WINDOW_WIDTH,
+                window_height: DEFAULT_WINDOW_HEIGH,
+            },
+        );
+
        // String versions of the locale are added here to simplify the serialize/deserialize logic
        let workbook = Workbook {
            shared_strings: vec![],
            defined_names: vec![],
-            worksheets: vec![Model::new_empty_worksheet("Sheet1", 1)],
+            worksheets: vec![Model::new_empty_worksheet("Sheet1", 1, &[&0])],
            styles: Default::default(),
            name: name.to_string(),
            settings: WorkbookSettings {
@@ -351,6 +383,7 @@ impl Model {
                last_modified: now,
            },
            tables: HashMap::new(),
+            views,
        };
        let parsed_formulas = Vec::new();
        let worksheets = &workbook.worksheets;
@@ -371,6 +404,7 @@ impl Model {
            locale,
            language,
            tz,
+            view_id: 0,
        };
        model.parse_formulas();
        Ok(model)
--- a/base/src/styles.rs
+++ b/base/src/styles.rs
@@ -161,26 +161,29 @@ impl Styles {

    pub fn create_named_style(&mut self, style_name: &str, style: &Style) -> Result<(), String> {
        let style_index = self.create_new_style(style);
-        self.add_named_cell_style(style_name, style_index)?;
-        Ok(())
+        self.add_named_cell_style(style_name, style_index)
    }

-    pub(crate) fn get_style_with_quote_prefix(&mut self, index: i32) -> i32 {
-        let mut style = self.get_style(index);
+    pub(crate) fn get_style_with_quote_prefix(&mut self, index: i32) -> Result<i32, String> {
+        let mut style = self.get_style(index)?;
        style.quote_prefix = true;
-        self.get_style_index_or_create(&style)
+        Ok(self.get_style_index_or_create(&style))
    }

-    pub(crate) fn get_style_with_format(&mut self, index: i32, num_fmt: &str) -> i32 {
-        let mut style = self.get_style(index);
+    pub(crate) fn get_style_with_format(
+        &mut self,
+        index: i32,
+        num_fmt: &str,
+    ) -> Result<i32, String> {
+        let mut style = self.get_style(index)?;
        style.num_fmt = num_fmt.to_string();
-        self.get_style_index_or_create(&style)
+        Ok(self.get_style_index_or_create(&style))
    }

-    pub(crate) fn get_style_without_quote_prefix(&mut self, index: i32) -> i32 {
-        let mut style = self.get_style(index);
+    pub(crate) fn get_style_without_quote_prefix(&mut self, index: i32) -> Result<i32, String> {
+        let mut style = self.get_style(index)?;
        style.quote_prefix = false;
-        self.get_style_index_or_create(&style)
+        Ok(self.get_style_index_or_create(&style))
    }

    pub(crate) fn style_is_quote_prefix(&self, index: i32) -> bool {
@@ -188,9 +191,11 @@ impl Styles {
        cell_xf.quote_prefix
    }

-    pub(crate) fn get_style(&self, index: i32) -> Style {
-        let cell_xf = &self.cell_xfs[index as usize];
-
+    pub(crate) fn get_style(&self, index: i32) -> Result<Style, String> {
+        let cell_xf = &self
+            .cell_xfs
+            .get(index as usize)
+            .ok_or("Invalid index provided".to_string())?;
        let border_id = cell_xf.border_id as usize;
        let fill_id = cell_xf.fill_id as usize;
        let font_id = cell_xf.font_id as usize;
@@ -198,14 +203,14 @@ impl Styles {
        let quote_prefix = cell_xf.quote_prefix;
        let alignment = cell_xf.alignment.clone();

-        Style {
+        Ok(Style {
            alignment,
            num_fmt: get_num_fmt(num_fmt_id, &self.num_fmts),
            fill: self.fills[fill_id].clone(),
            font: self.fonts[font_id].clone(),
            border: self.borders[border_id].clone(),
            quote_prefix,
-        }
+        })
    }
 }

@@ -221,8 +226,7 @@ impl Model {
        let style_index = self.workbook.styles.get_style_index_or_create(style);
        self.workbook
            .worksheet_mut(sheet)?
-            .set_cell_style(row, column, style_index);
-        Ok(())
+            .set_cell_style(row, column, style_index)
    }

    pub fn copy_cell_style(
@@ -237,9 +241,7 @@ impl Model {

        self.workbook
            .worksheet_mut(destination_cell.0)?
-            .set_cell_style(destination_cell.1, destination_cell.2, source_style_index);
-
-        Ok(())
+            .set_cell_style(destination_cell.1, destination_cell.2, source_style_index)
    }

    /// Sets the style "style_name" in cell
@@ -253,8 +255,7 @@ impl Model {
        let style_index = self.workbook.styles.get_style_index_by_name(style_name)?;
        self.workbook
            .worksheet_mut(sheet)?
-            .set_cell_style(row, column, style_index);
-        Ok(())
+            .set_cell_style(row, column, style_index)
    }

    pub fn set_sheet_style(&mut self, sheet: u32, style_name: &str) -> Result<(), String> {
--- a/base/src/test/engineering/test_complex.rs
+++ b/base/src/test/engineering/test_complex.rs
@@ -76,10 +76,16 @@ fn fn_imconjugate() {
 fn fn_imcos() {
    let mut model = new_empty_model();
    model._set("A1", r#"=IMCOS("4+3i")"#);
+    // In macos non intel this is "-6.58066304055116+7.58155274274655i"
+    model._set("A2", r#"=COMPLEX(-6.58066304055116, 7.58155274274654)"#);
+    model._set("A3", r#"=IMABS(IMSUB(A1, A2)) < G1"#);
+
+    // small number
+    model._set("G1", "0.0000001");

    model.evaluate();

-    assert_eq!(model._get_text("A1"), "-6.58066304055116+7.58155274274654i");
+    assert_eq!(model._get_text("A3"), "TRUE");
 }

 #[test]
--- a/base/src/test/mod.rs
+++ b/base/src/test/mod.rs
@@ -52,5 +52,7 @@ mod test_fn_type;
 mod test_frozen_rows_and_columns;
 mod test_get_cell_content;
 mod test_percentage;
+mod test_set_functions_error_handling;
 mod test_today;
+mod test_types;
 mod user_model;
--- a/base/src/test/test_actions.rs
+++ b/base/src/test/test_actions.rs
@@ -1,6 +1,6 @@
 #![allow(clippy::unwrap_used)]

-use crate::constants::LAST_COLUMN;
+use crate::constants::{DEFAULT_ROW_HEIGHT, LAST_COLUMN};
 use crate::model::Model;
 use crate::test::util::new_empty_model;
 use crate::types::Col;
@@ -87,7 +87,8 @@ fn test_insert_rows_styles() {
    let mut model = new_empty_model();

    assert!(
-        (21.0 - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs() < f64::EPSILON
+        (DEFAULT_ROW_HEIGHT - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs()
+            < f64::EPSILON
    );
    // sets height 42 in row 10
    model
@@ -106,7 +107,8 @@ fn test_insert_rows_styles() {

    // Row 10 has the default height
    assert!(
-        (21.0 - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs() < f64::EPSILON
+        (DEFAULT_ROW_HEIGHT - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs()
+            < f64::EPSILON
    );

    // Row 10 is now row 15
@@ -120,7 +122,8 @@ fn test_delete_rows_styles() {
    let mut model = new_empty_model();

    assert!(
-        (21.0 - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs() < f64::EPSILON
+        (DEFAULT_ROW_HEIGHT - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs()
+            < f64::EPSILON
    );
    // sets height 42 in row 10
    model
@@ -139,7 +142,8 @@ fn test_delete_rows_styles() {

    // Row 10 has the default height
    assert!(
-        (21.0 - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs() < f64::EPSILON
+        (DEFAULT_ROW_HEIGHT - model.workbook.worksheet(0).unwrap().row_height(10).unwrap()).abs()
+            < f64::EPSILON
    );

    // Row 10 is now row 5
--- a/base/src/test/test_column_width.rs
+++ b/base/src/test/test_column_width.rs
@@ -26,7 +26,7 @@ fn test_column_width() {
    assert!((worksheet.get_column_width(1).unwrap() - DEFAULT_COLUMN_WIDTH).abs() < f64::EPSILON);
    assert!((worksheet.get_column_width(2).unwrap() - 30.0).abs() < f64::EPSILON);
    assert!((worksheet.get_column_width(3).unwrap() - DEFAULT_COLUMN_WIDTH).abs() < f64::EPSILON);
-    assert_eq!(model.get_cell_style_index(0, 23, 2), 6);
+    assert_eq!(model.get_cell_style_index(0, 23, 2), Ok(6));
 }

 #[test]
@@ -53,7 +53,7 @@ fn test_column_width_lower_edge() {
    assert!(
        (worksheet.get_column_width(6).unwrap() - 10.0 * COLUMN_WIDTH_FACTOR).abs() < f64::EPSILON
    );
-    assert_eq!(model.get_cell_style_index(0, 23, 5), 1);
+    assert_eq!(model.get_cell_style_index(0, 23, 5), Ok(1));
 }

 #[test]
@@ -80,5 +80,5 @@ fn test_column_width_higher_edge() {
    );
    assert!((worksheet.get_column_width(16).unwrap() - 30.0).abs() < f64::EPSILON);
    assert!((worksheet.get_column_width(17).unwrap() - DEFAULT_COLUMN_WIDTH).abs() < f64::EPSILON);
-    assert_eq!(model.get_cell_style_index(0, 23, 16), 1);
+    assert_eq!(model.get_cell_style_index(0, 23, 16), Ok(1));
 }
--- a/base/src/test/test_general.rs
+++ b/base/src/test/test_general.rs
@@ -17,7 +17,9 @@ fn test_empty_model() {
 #[test]
 fn test_model_simple_evaluation() {
    let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "= 1 + 3".to_string());
+    model
+        .set_user_input(0, 1, 1, "= 1 + 3".to_string())
+        .unwrap();
    model.evaluate();
    let result = model._get_text_at(0, 1, 1);
    assert_eq!(result, *"4");
@@ -43,7 +45,7 @@ fn test_model_simple_evaluation_order() {
 #[test]
 fn test_model_invalid_formula() {
    let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "= 1 +".to_string());
+    model.set_user_input(0, 1, 1, "= 1 +".to_string()).unwrap();
    model.evaluate();
    let result = model._get_text_at(0, 1, 1);
    assert_eq!(result, *"#ERROR!");
@@ -54,8 +56,10 @@ fn test_model_invalid_formula() {
 #[test]
 fn test_model_dependencies() {
    let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "23".to_string()); // A1
-    model.set_user_input(0, 1, 2, "= A1* 2-4".to_string()); // B1
+    model.set_user_input(0, 1, 1, "23".to_string()).unwrap(); // A1
+    model
+        .set_user_input(0, 1, 2, "= A1* 2-4".to_string())
+        .unwrap(); // B1
    model.evaluate();
    let result = model._get_text_at(0, 1, 1);
    assert_eq!(result, *"23");
@@ -65,7 +69,9 @@ fn test_model_dependencies() {
    let result = model._get_formula("B1");
    assert_eq!(result, *"=A1*2-4");

-    model.set_user_input(0, 2, 1, "=SUM(A1, B1)".to_string()); // A2
+    model
+        .set_user_input(0, 2, 1, "=SUM(A1, B1)".to_string())
+        .unwrap(); // A2
    model.evaluate();
    let result = model._get_text_at(0, 2, 1);
    assert_eq!(result, *"65");
@@ -74,8 +80,10 @@ fn test_model_dependencies() {
 #[test]
 fn test_model_strings() {
    let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "Hello World".to_string());
-    model.set_user_input(0, 1, 2, "=A1".to_string());
+    model
+        .set_user_input(0, 1, 1, "Hello World".to_string())
+        .unwrap();
+    model.set_user_input(0, 1, 2, "=A1".to_string()).unwrap();
    model.evaluate();
    let result = model._get_text_at(0, 1, 1);
    assert_eq!(result, *"Hello World");
@@ -152,21 +160,35 @@ fn test_to_excel_precision_str() {
 #[test]
 fn test_booleans() {
    let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "true".to_string());
-    model.set_user_input(0, 2, 1, "TRUE".to_string());
-    model.set_user_input(0, 3, 1, "True".to_string());
-    model.set_user_input(0, 4, 1, "false".to_string());
-    model.set_user_input(0, 5, 1, "FALSE".to_string());
-    model.set_user_input(0, 6, 1, "False".to_string());
+    model.set_user_input(0, 1, 1, "true".to_string()).unwrap();
+    model.set_user_input(0, 2, 1, "TRUE".to_string()).unwrap();
+    model.set_user_input(0, 3, 1, "True".to_string()).unwrap();
+    model.set_user_input(0, 4, 1, "false".to_string()).unwrap();
+    model.set_user_input(0, 5, 1, "FALSE".to_string()).unwrap();
+    model.set_user_input(0, 6, 1, "False".to_string()).unwrap();

-    model.set_user_input(0, 1, 2, "=ISLOGICAL(A1)".to_string());
-    model.set_user_input(0, 2, 2, "=ISLOGICAL(A2)".to_string());
-    model.set_user_input(0, 3, 2, "=ISLOGICAL(A3)".to_string());
-    model.set_user_input(0, 4, 2, "=ISLOGICAL(A4)".to_string());
-    model.set_user_input(0, 5, 2, "=ISLOGICAL(A5)".to_string());
-    model.set_user_input(0, 6, 2, "=ISLOGICAL(A6)".to_string());
+    model
+        .set_user_input(0, 1, 2, "=ISLOGICAL(A1)".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 2, 2, "=ISLOGICAL(A2)".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 3, 2, "=ISLOGICAL(A3)".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 4, 2, "=ISLOGICAL(A4)".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 5, 2, "=ISLOGICAL(A5)".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 6, 2, "=ISLOGICAL(A6)".to_string())
+        .unwrap();

-    model.set_user_input(0, 1, 5, "=IF(false, True, FALSe)".to_string());
+    model
+        .set_user_input(0, 1, 5, "=IF(false, True, FALSe)".to_string())
+        .unwrap();

    model.evaluate();

@@ -191,19 +213,19 @@ fn test_booleans() {
 #[test]
 fn test_set_cell_style() {
    let mut model = new_empty_model();
-    let mut style = model.get_style_for_cell(0, 1, 1);
+    let mut style = model.get_style_for_cell(0, 1, 1).unwrap();
    assert!(!style.font.b);

    style.font.b = true;
    assert!(model.set_cell_style(0, 1, 1, &style).is_ok());

-    let mut style = model.get_style_for_cell(0, 1, 1);
+    let mut style = model.get_style_for_cell(0, 1, 1).unwrap();
    assert!(style.font.b);

    style.font.b = false;
    assert!(model.set_cell_style(0, 1, 1, &style).is_ok());

-    let style = model.get_style_for_cell(0, 1, 1);
+    let style = model.get_style_for_cell(0, 1, 1).unwrap();
    assert!(!style.font.b);
 }

@@ -211,21 +233,21 @@ fn test_set_cell_style() {
 fn test_copy_cell_style() {
    let mut model = new_empty_model();

-    let mut style = model.get_style_for_cell(0, 1, 1);
+    let mut style = model.get_style_for_cell(0, 1, 1).unwrap();
    style.font.b = true;
    assert!(model.set_cell_style(0, 1, 1, &style).is_ok());

-    let mut style = model.get_style_for_cell(0, 1, 2);
+    let mut style = model.get_style_for_cell(0, 1, 2).unwrap();
    style.font.i = true;
    assert!(model.set_cell_style(0, 1, 2, &style).is_ok());

    assert!(model.copy_cell_style((0, 1, 1), (0, 1, 2)).is_ok());

-    let style = model.get_style_for_cell(0, 1, 1);
+    let style = model.get_style_for_cell(0, 1, 1).unwrap();
    assert!(style.font.b);
    assert!(!style.font.i);

-    let style = model.get_style_for_cell(0, 1, 2);
+    let style = model.get_style_for_cell(0, 1, 2).unwrap();
    assert!(style.font.b);
    assert!(!style.font.i);
 }
@@ -234,15 +256,15 @@ fn test_copy_cell_style() {
 fn test_get_cell_style_index() {
    let mut model = new_empty_model();

-    let mut style = model.get_style_for_cell(0, 1, 1);
-    let style_index = model.get_cell_style_index(0, 1, 1);
+    let mut style = model.get_style_for_cell(0, 1, 1).unwrap();
+    let style_index = model.get_cell_style_index(0, 1, 1).unwrap();
    assert_eq!(style_index, 0);
    assert!(!style.font.b);

    style.font.b = true;
    assert!(model.set_cell_style(0, 1, 1, &style).is_ok());

-    let style_index = model.get_cell_style_index(0, 1, 1);
+    let style_index = model.get_cell_style_index(0, 1, 1).unwrap();
    assert_eq!(style_index, 1);
 }

@@ -250,29 +272,29 @@ fn test_get_cell_style_index() {
 fn test_model_set_cells_with_values_styles() {
    let mut model = new_empty_model();
    // Inputs
-    model.set_user_input(0, 1, 1, "21".to_string()); // A1
-    model.set_user_input(0, 2, 1, "2".to_string()); // A2
+    model.set_user_input(0, 1, 1, "21".to_string()).unwrap(); // A1
+    model.set_user_input(0, 2, 1, "2".to_string()).unwrap(); // A2

-    let style_index = model.get_cell_style_index(0, 1, 1);
+    let style_index = model.get_cell_style_index(0, 1, 1).unwrap();
    assert_eq!(style_index, 0);
-    let mut style = model.get_style_for_cell(0, 1, 1);
+    let mut style = model.get_style_for_cell(0, 1, 1).unwrap();
    style.font.b = true;
    assert!(model.set_cell_style(0, 1, 1, &style).is_ok());
    assert!(model.set_cell_style(0, 2, 1, &style).is_ok());
-    let style_index = model.get_cell_style_index(0, 1, 1);
+    let style_index = model.get_cell_style_index(0, 1, 1).unwrap();
    assert_eq!(style_index, 1);
-    let style_index = model.get_cell_style_index(0, 2, 1);
+    let style_index = model.get_cell_style_index(0, 2, 1).unwrap();
    assert_eq!(style_index, 1);

-    model.update_cell_with_number(0, 1, 2, 1.0);
-    model.update_cell_with_number(0, 2, 1, 2.0);
+    model.update_cell_with_number(0, 1, 2, 1.0).unwrap();
+    model.update_cell_with_number(0, 2, 1, 2.0).unwrap();

    model.evaluate();

    // Styles are not modified
-    let style_index = model.get_cell_style_index(0, 1, 1);
+    let style_index = model.get_cell_style_index(0, 1, 1).unwrap();
    assert_eq!(style_index, 1);
-    let style_index = model.get_cell_style_index(0, 2, 1);
+    let style_index = model.get_cell_style_index(0, 2, 1).unwrap();
    assert_eq!(style_index, 1);
 }

@@ -280,20 +302,20 @@ fn test_model_set_cells_with_values_styles() {
 fn test_style_fmt_id() {
    let mut model = new_empty_model();

-    let mut style = model.get_style_for_cell(0, 1, 1);
+    let mut style = model.get_style_for_cell(0, 1, 1).unwrap();
    style.num_fmt = "#.##".to_string();
    assert!(model.set_cell_style(0, 1, 1, &style).is_ok());
-    let style = model.get_style_for_cell(0, 1, 1);
+    let style = model.get_style_for_cell(0, 1, 1).unwrap();
    assert_eq!(style.num_fmt, "#.##");

-    let mut style = model.get_style_for_cell(0, 10, 1);
+    let mut style = model.get_style_for_cell(0, 10, 1).unwrap();
    style.num_fmt = "$$#,##0.0000".to_string();
    assert!(model.set_cell_style(0, 10, 1, &style).is_ok());
-    let style = model.get_style_for_cell(0, 10, 1);
+    let style = model.get_style_for_cell(0, 10, 1).unwrap();
    assert_eq!(style.num_fmt, "$$#,##0.0000");

    // Make sure old style is not touched
-    let style = model.get_style_for_cell(0, 1, 1);
+    let style = model.get_style_for_cell(0, 1, 1).unwrap();
    assert_eq!(style.num_fmt, "#.##");
 }

@@ -357,9 +379,13 @@ fn set_input_autocomplete() {
    let mut model = new_empty_model();
    model._set("A1", "1");
    model._set("A2", "2");
-    model.set_user_input(0, 3, 1, "=SUM(A1:A2".to_string());
+    model
+        .set_user_input(0, 3, 1, "=SUM(A1:A2".to_string())
+        .unwrap();
    // This will fail anyway
-    model.set_user_input(0, 4, 1, "=SUM(A1*".to_string());
+    model
+        .set_user_input(0, 4, 1, "=SUM(A1*".to_string())
+        .unwrap();
    model.evaluate();

    assert_eq!(model._get_formula("A3"), "=SUM(A1:A2)");
@@ -405,7 +431,7 @@ fn test_get_formatted_cell_value() {
    model._set("A5", "123.456");

    // change A5 format
-    let mut style = model.get_style_for_cell(0, 5, 1);
+    let mut style = model.get_style_for_cell(0, 5, 1).unwrap();
    style.num_fmt = "$#,##0.00".to_string();
    model.set_cell_style(0, 5, 1, &style).unwrap();

--- a/base/src/test/test_get_cell_content.rs
+++ b/base/src/test/test_get_cell_content.rs
@@ -5,8 +5,12 @@ use crate::test::util::new_empty_model;
 #[test]
 fn test_formulas() {
    let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "$100.348".to_string());
-    model.set_user_input(0, 1, 2, "=ISNUMBER(A1)".to_string());
+    model
+        .set_user_input(0, 1, 1, "$100.348".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 1, 2, "=ISNUMBER(A1)".to_string())
+        .unwrap();

    model.evaluate();

--- a/base/src/test/test_metadata.rs
+++ b/base/src/test/test_metadata.rs
@@ -3,7 +3,7 @@ use crate::test::util::new_empty_model;
 #[test]
 fn test_metadata_new_model() {
    let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "5.5".to_string());
+    model.set_user_input(0, 1, 1, "5.5".to_string()).unwrap();
    model.evaluate();
    let metadata = &model.workbook.metadata;
    assert_eq!(metadata.application, "IronCalc Sheets");
--- a/base/src/test/test_model_is_empty_cell.rs
+++ b/base/src/test/test_model_is_empty_cell.rs
@@ -14,7 +14,9 @@ fn test_is_empty_cell_non_existing_sheet() {
 fn test_is_empty_cell() {
    let mut model = new_empty_model();
    assert!(model.is_empty_cell(0, 3, 1).unwrap());
-    model.set_user_input(0, 3, 1, "Hello World".to_string());
+    model
+        .set_user_input(0, 3, 1, "Hello World".to_string())
+        .unwrap();
    assert!(!model.is_empty_cell(0, 3, 1).unwrap());
    model.cell_clear_contents(0, 3, 1).unwrap();
    assert!(model.is_empty_cell(0, 3, 1).unwrap());
--- a/base/src/test/test_quote_prefix.rs
+++ b/base/src/test/test_quote_prefix.rs
@@ -57,12 +57,12 @@ fn test_quote_prefix_enter() {
    model._set("A2", "=ISTEXT(A1)");
    model.evaluate();
    // We introduce a value with a "quote prefix" index
-    model.set_user_input(0, 1, 3, "'=A1".to_string());
+    model.set_user_input(0, 1, 3, "'=A1".to_string()).unwrap();
    model.evaluate();
    assert_eq!(model._get_text("C1"), *"=A1");

    // But if we enter with a quote_prefix but without the "'" it won't be quote_prefix
-    model.set_user_input(0, 1, 4, "=A1".to_string());
+    model.set_user_input(0, 1, 4, "=A1".to_string()).unwrap();
    model.evaluate();
    assert_eq!(model._get_text("D1"), *"123");
 }
@@ -75,7 +75,7 @@ fn test_quote_prefix_reenter() {
    model.evaluate();
    assert_eq!(model._get_text("A2"), *"TRUE");
    // We introduce a value with a "quote prefix" index
-    model.set_user_input(0, 1, 1, "123".to_string());
+    model.set_user_input(0, 1, 1, "123".to_string()).unwrap();
    model.evaluate();
    assert_eq!(model._get_text("A2"), *"FALSE");
 }
@@ -83,7 +83,7 @@ fn test_quote_prefix_reenter() {
 #[test]
 fn test_update_cell_quote() {
    let mut model = new_empty_model();
-    model.update_cell_with_text(0, 1, 1, "= 1 + 3");
+    model.update_cell_with_text(0, 1, 1, "= 1 + 3").unwrap();
    model.evaluate();
    assert_eq!(model._get_text("A1"), *"= 1 + 3");
    assert!(!model._has_formula("A1"));
@@ -92,12 +92,12 @@ fn test_update_cell_quote() {
 #[test]
 fn test_update_quote_prefix_reenter() {
    let mut model = new_empty_model();
-    model.update_cell_with_text(0, 1, 1, "123");
+    model.update_cell_with_text(0, 1, 1, "123").unwrap();
    model._set("A2", "=ISTEXT(A1)");
    model.evaluate();
    assert_eq!(model._get_text("A2"), *"TRUE");
    // We reenter as a number
-    model.update_cell_with_number(0, 1, 1, 123.0);
+    model.update_cell_with_number(0, 1, 1, 123.0).unwrap();
    model.evaluate();
    assert_eq!(model._get_text("A2"), *"FALSE");
 }
@@ -105,12 +105,12 @@ fn test_update_quote_prefix_reenter() {
 #[test]
 fn test_update_quote_prefix_reenter_bool() {
    let mut model = new_empty_model();
-    model.update_cell_with_text(0, 1, 1, "TRUE");
+    model.update_cell_with_text(0, 1, 1, "TRUE").unwrap();
    model._set("A2", "=ISTEXT(A1)");
    model.evaluate();
    assert_eq!(model._get_text("A2"), *"TRUE");
    // We enter a bool
-    model.update_cell_with_bool(0, 1, 1, true);
+    model.update_cell_with_bool(0, 1, 1, true).unwrap();
    model.evaluate();
    assert_eq!(model._get_text("A2"), *"FALSE");
 }
@@ -118,29 +118,29 @@ fn test_update_quote_prefix_reenter_bool() {
 #[test]
 fn test_update_quote_prefix_reenter_text() {
    let mut model = new_empty_model();
-    model.update_cell_with_text(0, 1, 1, "123");
+    model.update_cell_with_text(0, 1, 1, "123").unwrap();
    model._set("A2", "=ISTEXT(A1)");
    model.evaluate();
    assert_eq!(model._get_text("A2"), *"TRUE");
-    assert!(model.get_style_for_cell(0, 1, 1).quote_prefix);
+    assert!(model.get_style_for_cell(0, 1, 1).unwrap().quote_prefix);
    // We enter a string
-    model.update_cell_with_text(0, 1, 1, "Hello");
+    model.update_cell_with_text(0, 1, 1, "Hello").unwrap();
    model.evaluate();
    assert_eq!(model._get_text("A2"), *"TRUE");
-    assert!(!model.get_style_for_cell(0, 1, 1).quote_prefix);
+    assert!(!model.get_style_for_cell(0, 1, 1).unwrap().quote_prefix);
 }

 #[test]
 fn test_update_quote_prefix_reenter_text_2() {
    let mut model = new_empty_model();
-    model.update_cell_with_text(0, 1, 1, "123");
+    model.update_cell_with_text(0, 1, 1, "123").unwrap();
    model._set("A2", "=ISTEXT(A1)");
    model.evaluate();
    assert_eq!(model._get_text("A2"), *"TRUE");
-    assert!(model.get_style_for_cell(0, 1, 1).quote_prefix);
+    assert!(model.get_style_for_cell(0, 1, 1).unwrap().quote_prefix);
    // We enter another number
-    model.update_cell_with_text(0, 1, 1, "42");
+    model.update_cell_with_text(0, 1, 1, "42").unwrap();
    model.evaluate();
    assert_eq!(model._get_text("A2"), *"TRUE");
-    assert!(model.get_style_for_cell(0, 1, 1).quote_prefix);
+    assert!(model.get_style_for_cell(0, 1, 1).unwrap().quote_prefix);
 }
--- a/base/src/test/test_set_functions_error_handling.rs
+++ b/base/src/test/test_set_functions_error_handling.rs
@@ -0,0 +1,449 @@
+use crate::{expressions::token, test::util::new_empty_model, types::Cell};
+
+#[test]
+fn test_update_cell_with_text() {
+    let mut model = new_empty_model();
+
+    // Below are safe inputs
+    model.set_user_input(0, 1, 1, "Hello".to_string()).unwrap();
+
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid sheet
+    let update_result = model.update_cell_with_text(1, 1, 1, "new value");
+    assert_eq!(update_result, Err("Invalid sheet index".to_string()));
+
+    // Case2 : Invalid Row
+    let update_result = model.update_cell_with_text(0, 0, 1, "new value");
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case3 : Invalid Column
+    let update_result = model.update_cell_with_text(0, 1, 1048579, "new value");
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_update_cell_with_number() {
+    let mut model = new_empty_model();
+
+    // Below are safe inputs
+    model.update_cell_with_number(0, 1, 1, 10.0).unwrap();
+
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid sheet
+    let update_result = model.update_cell_with_number(1, 1, 1, 20.0);
+    assert_eq!(update_result, Err("Invalid sheet index".to_string()));
+
+    // Case2 : Invalid Row
+    let update_result = model.update_cell_with_number(0, 0, 1, 20.0);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case3 : Invalid Column
+    let update_result = model.update_cell_with_number(0, 1, 1048579, 20.0);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_update_cell_with_bool() {
+    let mut model = new_empty_model();
+
+    // Below are safe inputs
+    model.update_cell_with_bool(0, 1, 1, true).unwrap();
+
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid sheet
+    let update_result = model.update_cell_with_bool(1, 1, 1, false);
+    assert_eq!(update_result, Err("Invalid sheet index".to_string()));
+
+    // Case2 : Invalid Row
+    let update_result = model.update_cell_with_bool(0, 0, 1, false);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case3 : Invalid Column
+    let update_result = model.update_cell_with_bool(0, 1, 1048579, false);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_update_cell_with_formula() {
+    let mut model = new_empty_model();
+
+    // Below are safe inputs
+    model.update_cell_with_number(0, 1, 1, 10.0).unwrap();
+    model
+        .update_cell_with_formula(0, 1, 2, "=A1*2".to_string())
+        .unwrap();
+
+    model.evaluate();
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid sheet
+    let update_result = model.update_cell_with_formula(1, 1, 2, "=A1*2".to_string());
+    assert_eq!(update_result, Err("Invalid sheet index".to_string()));
+
+    // Case2 : Invalid Row
+    let update_result = model.update_cell_with_formula(0, 0, 2, "=A1*2".to_string());
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case3 : Invalid Column
+    let update_result = model.update_cell_with_formula(0, 1, 1048579, "=A1*2".to_string());
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_set_user_input() {
+    let mut model = new_empty_model();
+
+    // Below are safe inputs
+    model.update_cell_with_number(0, 1, 1, 10.0).unwrap();
+    model.evaluate();
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid sheet
+    let update_result = model.set_user_input(1, 1, 2, "20.0".to_string());
+    assert_eq!(update_result, Err("Invalid sheet index".to_string()));
+
+    // Case2 : Invalid Row
+    let update_result = model.set_user_input(0, 0, 2, "20.0".to_string());
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case3 : Invalid Column
+    let update_result = model.set_user_input(0, 1, 1048579, "20.0".to_string());
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_get_style_for_cell() {
+    let mut model = new_empty_model();
+
+    // Below are safe inputs
+    model.update_cell_with_number(0, 1, 1, 10.0).unwrap();
+    model.evaluate();
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid sheet
+    let update_result = model.get_style_for_cell(1, 1, 2);
+    assert_eq!(update_result, Err("Invalid sheet index".to_string()));
+
+    // ATTENTION : get_cell_style_index tries to get cell using row and col
+    // if we invalid row or column is given, it will return index 0.
+
+    // Case2 : Invalid Row
+    let update_result = model.get_style_for_cell(0, 0, 2);
+    assert!(update_result.is_ok());
+
+    // Case3 : Invalid Column
+    let update_result = model.get_style_for_cell(0, 1, 1048579);
+    assert!(update_result.is_ok());
+}
+
+#[test]
+fn test_get_cell_style_index() {
+    let mut model = new_empty_model();
+
+    // Below are safe inputs
+    model.update_cell_with_number(0, 1, 1, 10.0).unwrap();
+    model.evaluate();
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid sheet
+    let update_result = model.get_cell_style_index(1, 1, 2);
+    assert_eq!(update_result, Err("Invalid sheet index".to_string()));
+
+    // ATTENTION : get_cell_style_index tries to get cell using row and col
+    // if we invalid row or column is given, it will return index 0.
+
+    // Case2 : Invalid Row
+    let update_result = model.get_cell_style_index(0, 0, 2);
+    assert_eq!(update_result, Ok(0));
+
+    // Case3 : Invalid Column
+    let update_result = model.get_cell_style_index(0, 1, 1048579);
+    assert_eq!(update_result, Ok(0));
+}
+
+#[test]
+fn test_worksheet_update_cell() {
+    let mut model = new_empty_model();
+
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid Row
+    let update_result =
+        model
+            .workbook
+            .worksheet_mut(0)
+            .unwrap()
+            .update_cell(0, 1, Cell::new_number(10.0, 1));
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case2 : Invalid Column
+    let update_result =
+        model
+            .workbook
+            .worksheet_mut(0)
+            .unwrap()
+            .update_cell(1, 1048579, Cell::new_number(10.0, 1));
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_worksheet_set_cell_style() {
+    let mut model = new_empty_model();
+
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid Row
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_style(0, 1, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case2 : Invalid Column
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_style(1, 1048579, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_worksheet_set_cell_with_formula() {
+    let mut model = new_empty_model();
+
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid Row
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_with_formula(0, 1, 1, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case2 : Invalid Column
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_with_formula(1, 1048579, 1, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_worksheet_set_cell_with_number() {
+    let mut model = new_empty_model();
+
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid Row
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_with_number(0, 1, 1.0, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case2 : Invalid Column
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_with_number(1, 1048579, 1.0, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_worksheet_set_cell_with_string() {
+    let mut model = new_empty_model();
+
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid Row
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_with_string(0, 1, 1, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case2 : Invalid Column
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_with_string(1, 1048579, 1, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_worksheet_set_cell_with_boolean() {
+    let mut model = new_empty_model();
+
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid Row
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_with_boolean(0, 1, true, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case2 : Invalid Column
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_with_boolean(1, 1048579, true, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_worksheet_set_cell_with_error() {
+    let mut model = new_empty_model();
+
+    // Now testing all the possible error scenarios
+
+    // Case1: Invalid Row
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_with_error(0, 1, token::Error::ERROR, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case2 : Invalid Column
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_with_error(1, 1048579, token::Error::ERROR, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_worksheet_cell_clear_contents() {
+    let mut model = new_empty_model();
+
+    model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .update_cell(1, 1, Cell::new_number(10.0, 1))
+        .unwrap();
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid Row
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .cell_clear_contents(0, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case2 : Invalid Column
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .cell_clear_contents(1, 1048579);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case3 : Valid case
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .cell_clear_contents(1, 1);
+    assert_eq!(update_result, Ok(()))
+}
+
+#[test]
+fn test_worksheet_cell_clear_contents_with_style() {
+    let mut model = new_empty_model();
+
+    model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .update_cell(1, 1, Cell::new_number(10.0, 1))
+        .unwrap();
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid Row
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .cell_clear_contents_with_style(0, 1, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case2 : Invalid Column
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .cell_clear_contents_with_style(1, 1048579, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case3 : Valid case
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .cell_clear_contents_with_style(1, 1, 1);
+    assert_eq!(update_result, Ok(()))
+}
+
+#[test]
+fn workbook_styles_get_style_error_handling() {
+    let model = new_empty_model();
+
+    // case 1 : Invalid index
+    assert_eq!(
+        model.workbook.styles.get_style(15),
+        Err("Invalid index provided".to_string())
+    );
+}
+
+#[test]
+fn workbook_styles_get_style_without_quote_prefix_error_handling() {
+    let mut model = new_empty_model();
+
+    // case 1 : Invalid index
+    assert_eq!(
+        model.workbook.styles.get_style_without_quote_prefix(15),
+        Err("Invalid index provided".to_string())
+    );
+}
+
+#[test]
+fn workbook_styles_get_style_with_format_error_handling() {
+    let mut model = new_empty_model();
+
+    // case 1 : Invalid index
+    assert_eq!(
+        model
+            .workbook
+            .styles
+            .get_style_with_format(15, "dummy_num_format"),
+        Err("Invalid index provided".to_string())
+    );
+}
+
+#[test]
+fn workbook_styles_get_style_with_quote_prefix_handling() {
+    let mut model = new_empty_model();
+
+    // case 1 : Invalid index
+    assert_eq!(
+        model.workbook.styles.get_style_with_quote_prefix(15),
+        Err("Invalid index provided".to_string())
+    );
+}
--- a/base/src/test/test_set_user_input.rs
+++ b/base/src/test/test_set_user_input.rs
@@ -5,16 +5,28 @@ use crate::{cell::CellValue, test::util::new_empty_model};
 #[test]
 fn test_currencies() {
    let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "$100.348".to_string());
-    model.set_user_input(0, 1, 2, "=ISNUMBER(A1)".to_string());
+    model
+        .set_user_input(0, 1, 1, "$100.348".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 1, 2, "=ISNUMBER(A1)".to_string())
+        .unwrap();

-    model.set_user_input(0, 2, 1, "$ 100.348".to_string());
-    model.set_user_input(0, 2, 2, "=ISNUMBER(A2)".to_string());
+    model
+        .set_user_input(0, 2, 1, "$ 100.348".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 2, 2, "=ISNUMBER(A2)".to_string())
+        .unwrap();

-    model.set_user_input(0, 3, 1, "100$".to_string());
-    model.set_user_input(0, 3, 2, "=ISNUMBER(A3)".to_string());
+    model.set_user_input(0, 3, 1, "100$".to_string()).unwrap();
+    model
+        .set_user_input(0, 3, 2, "=ISNUMBER(A3)".to_string())
+        .unwrap();

-    model.set_user_input(0, 4, 1, "3.1415926$".to_string());
+    model
+        .set_user_input(0, 4, 1, "3.1415926$".to_string())
+        .unwrap();

    model.evaluate();

@@ -43,9 +55,9 @@ fn test_currencies() {
 #[test]
 fn scientific() {
    let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "3e-4".to_string());
-    model.set_user_input(0, 2, 1, "5e-4$".to_string());
-    model.set_user_input(0, 3, 1, "6e-4%".to_string());
+    model.set_user_input(0, 1, 1, "3e-4".to_string()).unwrap();
+    model.set_user_input(0, 2, 1, "5e-4$".to_string()).unwrap();
+    model.set_user_input(0, 3, 1, "6e-4%".to_string()).unwrap();

    model.evaluate();

@@ -61,9 +73,13 @@ fn scientific() {
 #[test]
 fn test_percentage() {
    let mut model = new_empty_model();
-    model.set_user_input(0, 10, 1, "50%".to_string());
-    model.set_user_input(0, 10, 2, "=ISNUMBER(A10)".to_string());
-    model.set_user_input(0, 11, 1, "55.759%".to_string());
+    model.set_user_input(0, 10, 1, "50%".to_string()).unwrap();
+    model
+        .set_user_input(0, 10, 2, "=ISNUMBER(A10)".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 11, 1, "55.759%".to_string())
+        .unwrap();

    model.evaluate();

@@ -81,8 +97,8 @@ fn test_percentage_ops() {
    let mut model = new_empty_model();
    model._set("A1", "5%");
    model._set("A2", "20%");
-    model.set_user_input(0, 3, 1, "=A1+A2".to_string());
-    model.set_user_input(0, 4, 1, "=A1*A2".to_string());
+    model.set_user_input(0, 3, 1, "=A1+A2".to_string()).unwrap();
+    model.set_user_input(0, 4, 1, "=A1*A2".to_string()).unwrap();

    model.evaluate();

@@ -93,11 +109,19 @@ fn test_percentage_ops() {
 #[test]
 fn test_numbers() {
    let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "1,000,000".to_string());
+    model
+        .set_user_input(0, 1, 1, "1,000,000".to_string())
+        .unwrap();

-    model.set_user_input(0, 20, 1, "50,123.549".to_string());
-    model.set_user_input(0, 21, 1, "50,12.549".to_string());
-    model.set_user_input(0, 22, 1, "1,234567".to_string());
+    model
+        .set_user_input(0, 20, 1, "50,123.549".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 21, 1, "50,12.549".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 22, 1, "1,234567".to_string())
+        .unwrap();

    model.evaluate();

@@ -131,7 +155,7 @@ fn test_numbers() {
 #[test]
 fn test_negative_numbers() {
    let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "-100".to_string());
+    model.set_user_input(0, 1, 1, "-100".to_string()).unwrap();

    model.evaluate();

@@ -144,15 +168,19 @@ fn test_negative_numbers() {
 #[test]
 fn test_negative_currencies() {
    let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "-$100".to_string());
-    model.set_user_input(0, 2, 1, "-$99.123".to_string());
+    model.set_user_input(0, 1, 1, "-$100".to_string()).unwrap();
+    model
+        .set_user_input(0, 2, 1, "-$99.123".to_string())
+        .unwrap();
    // This is valid!
-    model.set_user_input(0, 3, 1, "$-345".to_string());
+    model.set_user_input(0, 3, 1, "$-345".to_string()).unwrap();

-    model.set_user_input(0, 1, 2, "-200$".to_string());
-    model.set_user_input(0, 2, 2, "-92.689$".to_string());
+    model.set_user_input(0, 1, 2, "-200$".to_string()).unwrap();
+    model
+        .set_user_input(0, 2, 2, "-92.689$".to_string())
+        .unwrap();
    // This is valid!
-    model.set_user_input(0, 3, 2, "-22$".to_string());
+    model.set_user_input(0, 3, 2, "-22$".to_string()).unwrap();

    model.evaluate();

@@ -174,8 +202,10 @@ fn test_formulas() {
    let mut model = new_empty_model();
    model._set("A1", "$100");
    model._set("A2", "$200");
-    model.set_user_input(0, 3, 1, "=A1+A2".to_string());
-    model.set_user_input(0, 4, 1, "=SUM(A1:A3)".to_string());
+    model.set_user_input(0, 3, 1, "=A1+A2".to_string()).unwrap();
+    model
+        .set_user_input(0, 4, 1, "=SUM(A1:A3)".to_string())
+        .unwrap();

    model.evaluate();

@@ -198,9 +228,9 @@ fn test_product() {
    model._set("A2", "$5");
    model._set("A3", "4");

-    model.set_user_input(0, 1, 2, "=A1*A2".to_string());
-    model.set_user_input(0, 2, 2, "=A1*A3".to_string());
-    model.set_user_input(0, 3, 2, "=A1*3".to_string());
+    model.set_user_input(0, 1, 2, "=A1*A2".to_string()).unwrap();
+    model.set_user_input(0, 2, 2, "=A1*A3".to_string()).unwrap();
+    model.set_user_input(0, 3, 2, "=A1*3".to_string()).unwrap();

    model.evaluate();

@@ -216,10 +246,12 @@ fn test_division() {
    model._set("A2", "$5");
    model._set("A3", "4");

-    model.set_user_input(0, 1, 2, "=A1/A2".to_string());
-    model.set_user_input(0, 2, 2, "=A1/A3".to_string());
-    model.set_user_input(0, 3, 2, "=A1/2".to_string());
-    model.set_user_input(0, 4, 2, "=100/A2".to_string());
+    model.set_user_input(0, 1, 2, "=A1/A2".to_string()).unwrap();
+    model.set_user_input(0, 2, 2, "=A1/A3".to_string()).unwrap();
+    model.set_user_input(0, 3, 2, "=A1/2".to_string()).unwrap();
+    model
+        .set_user_input(0, 4, 2, "=100/A2".to_string())
+        .unwrap();

    model.evaluate();

@@ -235,54 +267,54 @@ fn test_some_complex_examples() {
    // $3.00 / 2 = $1.50
    model._set("A1", "$3.00");
    model._set("A2", "2");
-    model.set_user_input(0, 3, 1, "=A1/A2".to_string());
+    model.set_user_input(0, 3, 1, "=A1/A2".to_string()).unwrap();

    // $3 / 2 = $1
    model._set("B1", "$3");
    model._set("B2", "2");
-    model.set_user_input(0, 3, 2, "=B1/B2".to_string());
+    model.set_user_input(0, 3, 2, "=B1/B2".to_string()).unwrap();

    // $5.00 * 25% = 25% * $5.00 = $1.25
    model._set("C1", "$5.00");
    model._set("C2", "25%");
-    model.set_user_input(0, 3, 3, "=C1*C2".to_string());
-    model.set_user_input(0, 4, 3, "=C2*C1".to_string());
+    model.set_user_input(0, 3, 3, "=C1*C2".to_string()).unwrap();
+    model.set_user_input(0, 4, 3, "=C2*C1".to_string()).unwrap();

    // $5 * 75% = 75% * $5 = $1
    model._set("D1", "$5");
    model._set("D2", "75%");
-    model.set_user_input(0, 3, 4, "=D1*D2".to_string());
-    model.set_user_input(0, 4, 4, "=D2*D1".to_string());
+    model.set_user_input(0, 3, 4, "=D1*D2".to_string()).unwrap();
+    model.set_user_input(0, 4, 4, "=D2*D1".to_string()).unwrap();

    // $10 + $9.99 = $9.99 + $10 = $19.99
    model._set("E1", "$10");
    model._set("E2", "$9.99");
-    model.set_user_input(0, 3, 5, "=E1+E2".to_string());
-    model.set_user_input(0, 4, 5, "=E2+E1".to_string());
+    model.set_user_input(0, 3, 5, "=E1+E2".to_string()).unwrap();
+    model.set_user_input(0, 4, 5, "=E2+E1".to_string()).unwrap();

    // $2 * 2 = 2 * $2 = $4
    model._set("F1", "$2");
    model._set("F2", "2");
-    model.set_user_input(0, 3, 6, "=F1*F2".to_string());
-    model.set_user_input(0, 4, 6, "=F2*F1".to_string());
+    model.set_user_input(0, 3, 6, "=F1*F2".to_string()).unwrap();
+    model.set_user_input(0, 4, 6, "=F2*F1".to_string()).unwrap();

    // $2.50 * 2 = 2 * $2.50 = $5.00
    model._set("G1", "$2.50");
    model._set("G2", "2");
-    model.set_user_input(0, 3, 7, "=G1*G2".to_string());
-    model.set_user_input(0, 4, 7, "=G2*G1".to_string());
+    model.set_user_input(0, 3, 7, "=G1*G2".to_string()).unwrap();
+    model.set_user_input(0, 4, 7, "=G2*G1".to_string()).unwrap();

    // $2 * 2.5 = 2.5 * $2 = $5
    model._set("H1", "$2");
    model._set("H2", "2.5");
-    model.set_user_input(0, 3, 8, "=H1*H2".to_string());
-    model.set_user_input(0, 4, 8, "=H2*H1".to_string());
+    model.set_user_input(0, 3, 8, "=H1*H2".to_string()).unwrap();
+    model.set_user_input(0, 4, 8, "=H2*H1".to_string()).unwrap();

    // 10% * 1,000 = 1,000 * 10% = 100
    model._set("I1", "10%");
    model._set("I2", "1,000");
-    model.set_user_input(0, 3, 9, "=I1*I2".to_string());
-    model.set_user_input(0, 4, 9, "=I2*I1".to_string());
+    model.set_user_input(0, 3, 9, "=I1*I2".to_string()).unwrap();
+    model.set_user_input(0, 4, 9, "=I2*I1".to_string()).unwrap();

    model.evaluate();

@@ -320,9 +352,15 @@ fn test_financial_functions() {
    model._set("A3", "10");
    model._set("A4", "$10,000");

-    model.set_user_input(0, 5, 1, "=PMT(A2/12,A3,A4)".to_string());
-    model.set_user_input(0, 6, 1, "=PMT(A2/12,A3,A4,,1)".to_string());
-    model.set_user_input(0, 7, 1, "=PMT(0.2, 3, -200)".to_string());
+    model
+        .set_user_input(0, 5, 1, "=PMT(A2/12,A3,A4)".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 6, 1, "=PMT(A2/12,A3,A4,,1)".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 7, 1, "=PMT(0.2, 3, -200)".to_string())
+        .unwrap();

    model.evaluate();

@@ -339,9 +377,15 @@ fn test_sum_function() {
    model._set("A1", "$100");
    model._set("A2", "$300");

-    model.set_user_input(0, 1, 2, "=SUM(A:A)".to_string());
-    model.set_user_input(0, 2, 2, "=SUM(A1:A2)".to_string());
-    model.set_user_input(0, 3, 2, "=SUM(A1, A2, A3)".to_string());
+    model
+        .set_user_input(0, 1, 2, "=SUM(A:A)".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 2, 2, "=SUM(A1:A2)".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 3, 2, "=SUM(A1, A2, A3)".to_string())
+        .unwrap();

    model.evaluate();

@@ -353,7 +397,7 @@ fn test_sum_function() {
 #[test]
 fn test_number() {
    let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "3".to_string());
+    model.set_user_input(0, 1, 1, "3".to_string()).unwrap();

    model.evaluate();

@@ -367,7 +411,9 @@ fn test_number() {
 #[test]
 fn test_currencies_eur_prefix() {
    let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "€100.348".to_string());
+    model
+        .set_user_input(0, 1, 1, "€100.348".to_string())
+        .unwrap();

    model.evaluate();

@@ -381,19 +427,27 @@ fn test_currencies_eur_prefix() {
 #[test]
 fn test_currencies_eur_suffix() {
    let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "100.348€".to_string());
-    model.set_user_input(0, 2, 1, "25€".to_string());
+    model
+        .set_user_input(0, 1, 1, "100.348€".to_string())
+        .unwrap();
+    model.set_user_input(0, 2, 1, "25€".to_string()).unwrap();

    // negatives
-    model.set_user_input(0, 1, 2, "-123.348€".to_string());
-    model.set_user_input(0, 2, 2, "-42€".to_string());
+    model
+        .set_user_input(0, 1, 2, "-123.348€".to_string())
+        .unwrap();
+    model.set_user_input(0, 2, 2, "-42€".to_string()).unwrap();

    // with a space
-    model.set_user_input(0, 1, 3, "101.348 €".to_string());
-    model.set_user_input(0, 2, 3, "26 €".to_string());
+    model
+        .set_user_input(0, 1, 3, "101.348 €".to_string())
+        .unwrap();
+    model.set_user_input(0, 2, 3, "26 €".to_string()).unwrap();

-    model.set_user_input(0, 1, 4, "-12.348 €".to_string());
-    model.set_user_input(0, 2, 4, "-45 €".to_string());
+    model
+        .set_user_input(0, 1, 4, "-12.348 €".to_string())
+        .unwrap();
+    model.set_user_input(0, 2, 4, "-45 €".to_string()).unwrap();

    model.evaluate();

@@ -449,9 +503,15 @@ fn test_sum_function_eur() {
    model._set("A1", "€100");
    model._set("A2", "€300");

-    model.set_user_input(0, 1, 2, "=SUM(A:A)".to_string());
-    model.set_user_input(0, 2, 2, "=SUM(A1:A2)".to_string());
-    model.set_user_input(0, 3, 2, "=SUM(A1, A2, A3)".to_string());
+    model
+        .set_user_input(0, 1, 2, "=SUM(A:A)".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 2, 2, "=SUM(A1:A2)".to_string())
+        .unwrap();
+    model
+        .set_user_input(0, 3, 2, "=SUM(A1, A2, A3)".to_string())
+        .unwrap();

    model.evaluate();

@@ -463,7 +523,9 @@ fn test_sum_function_eur() {
 #[test]
 fn input_dates() {
    let mut model = new_empty_model();
-    model.set_user_input(0, 1, 1, "3/4/2025".to_string());
+    model
+        .set_user_input(0, 1, 1, "3/4/2025".to_string())
+        .unwrap();

    model.evaluate();

@@ -474,7 +536,9 @@ fn input_dates() {
    );

    // further date assignments do not change the format
-    model.set_user_input(0, 1, 1, "08-08-2028".to_string());
+    model
+        .set_user_input(0, 1, 1, "08-08-2028".to_string())
+        .unwrap();
    model.evaluate();
    assert_eq!(model._get_text("A1"), "8/8/2028");
 }
--- a/base/src/test/test_sheet_markup.rs
+++ b/base/src/test/test_sheet_markup.rs
@@ -14,7 +14,7 @@ fn test_sheet_markup() {
    model._set("A4", "Total");
    model._set("B4", "=SUM(B2:B3)");

-    let mut style = model.get_style_for_cell(0, 1, 1);
+    let mut style = model.get_style_for_cell(0, 1, 1).unwrap();
    style.font.b = true;
    model.set_cell_style(0, 1, 1, &style).unwrap();
    model.set_cell_style(0, 1, 2, &style).unwrap();
--- a/base/src/test/test_sheets.rs
+++ b/base/src/test/test_sheets.rs
@@ -138,14 +138,14 @@ fn test_insert_sheet() {

    // Insert the sheet at the end and check the formula
    assert!(model.insert_sheet("Bacchus", 1, None).is_ok());
-    model.set_user_input(1, 3, 1, "42".to_string());
+    model.set_user_input(1, 3, 1, "42".to_string()).unwrap();
    model.evaluate();
    assert_eq!(model._get_text("A1"), "42");
    assert_eq!(model._get_text("A2"), "#REF!");

    // Insert a sheet in between the other two
    assert!(model.insert_sheet("Dionysus", 1, None).is_ok());
-    model.set_user_input(1, 3, 1, "111".to_string());
+    model.set_user_input(1, 3, 1, "111".to_string()).unwrap();
    model.evaluate();
    assert_eq!(model._get_text("A1"), "42");
    assert_eq!(model._get_text("A2"), "111");
@@ -176,7 +176,7 @@ fn test_rename_sheet() {
    let mut model = new_empty_model();
    model.new_sheet();
    model._set("A1", "=NewSheet!A3");
-    model.set_user_input(1, 3, 1, "25".to_string());
+    model.set_user_input(1, 3, 1, "25".to_string()).unwrap();
    model.evaluate();
    assert_eq!(model._get_text("A1"), "#REF!");
    assert!(model.rename_sheet("Sheet2", "NewSheet").is_ok());
@@ -189,7 +189,7 @@ fn test_rename_sheet_by_index() {
    let mut model = new_empty_model();
    model.new_sheet();
    model._set("A1", "=NewSheet!A1");
-    model.set_user_input(1, 1, 1, "25".to_string());
+    model.set_user_input(1, 1, 1, "25".to_string()).unwrap();
    model.evaluate();
    assert_eq!(model._get_text("A1"), "#REF!");
    assert!(model.rename_sheet_by_index(1, "NewSheet").is_ok());
--- a/base/src/test/test_styles.rs
+++ b/base/src/test/test_styles.rs
@@ -7,10 +7,10 @@ use crate::types::Style;
 fn test_model_set_cells_with_values_styles() {
    let mut model = new_empty_model();
    // Inputs
-    model.set_user_input(0, 1, 1, "21".to_string()); // A1
-    model.set_user_input(0, 2, 1, "42".to_string()); // A2
+    model.set_user_input(0, 1, 1, "21".to_string()).unwrap(); // A1
+    model.set_user_input(0, 2, 1, "42".to_string()).unwrap(); // A2

-    let style_base = model.get_style_for_cell(0, 1, 1);
+    let style_base = model.get_style_for_cell(0, 1, 1).unwrap();
    let mut style = style_base.clone();
    style.font.b = true;
    style.num_fmt = "#,##0.00".to_string();
@@ -19,7 +19,7 @@ fn test_model_set_cells_with_values_styles() {
    let mut style = style_base;
    style.num_fmt = "#,##0.00".to_string();
    assert!(model.set_cell_style(0, 2, 1, &style).is_ok());
-    let style: Style = model.get_style_for_cell(0, 2, 1);
+    let style: Style = model.get_style_for_cell(0, 2, 1).unwrap();
    assert_eq!(style.num_fmt, "#,##0.00".to_string());
 }

@@ -27,21 +27,21 @@ fn test_model_set_cells_with_values_styles() {
 fn test_named_styles() {
    let mut model = new_empty_model();
    model._set("A1", "42");
-    let mut style = model.get_style_for_cell(0, 1, 1);
+    let mut style = model.get_style_for_cell(0, 1, 1).unwrap();
    style.font.b = true;
    assert!(model.set_cell_style(0, 1, 1, &style).is_ok());
-    let bold_style_index = model.get_cell_style_index(0, 1, 1);
+    let bold_style_index = model.get_cell_style_index(0, 1, 1).unwrap();
    let e = model
        .workbook
        .styles
        .add_named_cell_style("bold", bold_style_index);
    assert!(e.is_ok());
    model._set("A2", "420");
-    let a2_style_index = model.get_cell_style_index(0, 2, 1);
+    let a2_style_index = model.get_cell_style_index(0, 2, 1).unwrap();
    assert!(a2_style_index != bold_style_index);
    let e = model.set_cell_style_by_name(0, 2, 1, "bold");
    assert!(e.is_ok());
-    assert_eq!(model.get_cell_style_index(0, 2, 1), bold_style_index);
+    assert_eq!(model.get_cell_style_index(0, 2, 1), Ok(bold_style_index));
 }

 #[test]
@@ -49,7 +49,7 @@ fn test_create_named_style() {
    let mut model = new_empty_model();
    model._set("A1", "42");

-    let mut style = model.get_style_for_cell(0, 1, 1);
+    let mut style = model.get_style_for_cell(0, 1, 1).unwrap();
    assert!(!style.font.b);

    style.font.b = true;
@@ -59,6 +59,6 @@ fn test_create_named_style() {
    let e = model.set_cell_style_by_name(0, 1, 1, "bold");
    assert!(e.is_ok());

-    let style = model.get_style_for_cell(0, 1, 1);
+    let style = model.get_style_for_cell(0, 1, 1).unwrap();
    assert!(style.font.b);
 }
--- a/base/src/test/test_types.rs
+++ b/base/src/test/test_types.rs
@@ -0,0 +1,24 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::types::{Alignment, HorizontalAlignment, VerticalAlignment};
+
+#[test]
+fn alignment_default() {
+    let alignment = Alignment::default();
+    assert_eq!(
+        alignment,
+        Alignment {
+            horizontal: HorizontalAlignment::General,
+            vertical: VerticalAlignment::Bottom,
+            wrap_text: false
+        }
+    );
+
+    let s = serde_json::to_string(&alignment).unwrap();
+    // defaults stringifies as an empty object
+    assert_eq!(s, "{}");
+
+    let a: Alignment = serde_json::from_str("{}").unwrap();
+
+    assert_eq!(a, alignment)
+}
--- a/base/src/test/test_worksheet.rs
+++ b/base/src/test/test_worksheet.rs
@@ -100,7 +100,9 @@ fn test_worksheet_dimension_progressive() {
        }
    );

-    model.set_user_input(0, 30, 50, "Hello World".to_string());
+    model
+        .set_user_input(0, 30, 50, "Hello World".to_string())
+        .unwrap();
    assert_eq!(
        model.workbook.worksheet(0).unwrap().dimension(),
        WorksheetDimension {
@@ -111,7 +113,9 @@ fn test_worksheet_dimension_progressive() {
        }
    );

-    model.set_user_input(0, 10, 15, "Hello World".to_string());
+    model
+        .set_user_input(0, 10, 15, "Hello World".to_string())
+        .unwrap();
    assert_eq!(
        model.workbook.worksheet(0).unwrap().dimension(),
        WorksheetDimension {
@@ -122,7 +126,9 @@ fn test_worksheet_dimension_progressive() {
        }
    );

-    model.set_user_input(0, 5, 25, "Hello World".to_string());
+    model
+        .set_user_input(0, 5, 25, "Hello World".to_string())
+        .unwrap();
    assert_eq!(
        model.workbook.worksheet(0).unwrap().dimension(),
        WorksheetDimension {
@@ -133,7 +139,9 @@ fn test_worksheet_dimension_progressive() {
        }
    );

-    model.set_user_input(0, 10, 250, "Hello World".to_string());
+    model
+        .set_user_input(0, 10, 250, "Hello World".to_string())
+        .unwrap();
    assert_eq!(
        model.workbook.worksheet(0).unwrap().dimension(),
        WorksheetDimension {
@@ -162,12 +170,14 @@ fn test_worksheet_navigate_to_edge_in_direction() {
    for (row_index, row) in inline_spreadsheet.into_iter().enumerate() {
        for (column_index, value) in row.into_iter().enumerate() {
            if value != 0 {
-                model.update_cell_with_number(
-                    0,
-                    (row_index as i32) + 1,
-                    (column_index as i32) + 1,
-                    value.into(),
-                );
+                model
+                    .update_cell_with_number(
+                        0,
+                        (row_index as i32) + 1,
+                        (column_index as i32) + 1,
+                        value.into(),
+                    )
+                    .unwrap();
            }
        }
    }
--- a/base/src/test/user_model/mod.rs
+++ b/base/src/test/user_model/mod.rs
@@ -1,10 +1,21 @@
 mod test_add_delete_sheets;
+mod test_autofill_columns;
+mod test_autofill_rows;
+mod test_border;
 mod test_clear_cells;
 mod test_diff_queue;
 mod test_evaluation;
 mod test_general;
+mod test_grid_lines;
+mod test_keyboard_navigation;
+mod test_on_area_selection;
+mod test_on_expand_selected_range;
+mod test_on_paste_styles;
+mod test_paste_csv;
 mod test_rename_sheet;
 mod test_row_column;
 mod test_styles;
 mod test_to_from_bytes;
 mod test_undo_redo;
+mod test_view;
+mod test_window_size;
--- a/base/src/test/user_model/test_add_delete_sheets.rs
+++ b/base/src/test/user_model/test_add_delete_sheets.rs
@@ -5,13 +5,13 @@ use crate::{constants::DEFAULT_COLUMN_WIDTH, UserModel};
 #[test]
 fn add_undo_redo() {
    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    model.new_sheet();
+    model.new_sheet().unwrap();
    model.set_user_input(1, 1, 1, "=1 + 1").unwrap();
    model.set_user_input(1, 1, 2, "=A1*3").unwrap();
    model
        .set_column_width(1, 5, 5.0 * DEFAULT_COLUMN_WIDTH)
        .unwrap();
-    model.new_sheet();
+    model.new_sheet().unwrap();
    model.set_user_input(2, 1, 1, "=Sheet2!B1").unwrap();

    model.undo().unwrap();
@@ -59,7 +59,7 @@ fn set_sheet_color() {
 #[test]
 fn new_sheet_propagates() {
    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    model.new_sheet();
+    model.new_sheet().unwrap();

    let send_queue = model.flush_send_queue();

@@ -72,7 +72,7 @@ fn new_sheet_propagates() {
 #[test]
 fn delete_sheet_propagates() {
    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
-    model.new_sheet();
+    model.new_sheet().unwrap();
    model.delete_sheet(0).unwrap();

    let send_queue = model.flush_send_queue();
@@ -82,3 +82,23 @@ fn delete_sheet_propagates() {
    let sheets_info = model2.get_worksheets_properties();
    assert_eq!(sheets_info.len(), 1);
 }
+
+#[test]
+fn delete_last_sheet() {
+    // Deleting the last sheet, selects the previous
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.new_sheet().unwrap();
+    model.new_sheet().unwrap();
+    model.set_selected_sheet(2).unwrap();
+    model.delete_sheet(2).unwrap();
+
+    assert_eq!(model.get_selected_sheet(), 1);
+}
+
+#[test]
+fn new_sheet_selects_it() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    assert_eq!(model.get_selected_sheet(), 0);
+    model.new_sheet().unwrap();
+    assert_eq!(model.get_selected_sheet(), 1);
+}
--- a/base/src/test/user_model/test_autofill_columns.rs
+++ b/base/src/test/user_model/test_autofill_columns.rs
@@ -0,0 +1,404 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::constants::{LAST_COLUMN, LAST_ROW};
+use crate::expressions::types::Area;
+use crate::test::util::new_empty_model;
+use crate::UserModel;
+
+#[test]
+fn basic_tests() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    // This is cell A3
+    model.set_user_input(0, 3, 1, "alpha").unwrap();
+    // We autofill from A3 to C3
+    model
+        .auto_fill_columns(
+            &Area {
+                sheet: 0,
+                row: 3,
+                column: 1,
+                width: 1,
+                height: 1,
+            },
+            5,
+        )
+        .unwrap();
+    // B3
+    assert_eq!(
+        model.get_formatted_cell_value(0, 3, 2),
+        Ok("alpha".to_string())
+    );
+    // C3
+    assert_eq!(
+        model.get_formatted_cell_value(0, 3, 3),
+        Ok("alpha".to_string())
+    );
+}
+
+#[test]
+fn one_cell_right() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.set_user_input(0, 1, 1, "23").unwrap();
+    model
+        .auto_fill_columns(
+            &Area {
+                sheet: 0,
+                row: 1,
+                column: 1,
+                width: 1,
+                height: 1,
+            },
+            2,
+        )
+        .unwrap();
+    // B1
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 2),
+        Ok("23".to_string())
+    );
+}
+
+#[test]
+fn alpha_beta_gamma() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    // cells A1:B3
+    model.set_user_input(0, 1, 1, "Alpher").unwrap(); // A1
+    model.set_user_input(0, 1, 2, "Bethe").unwrap(); // B1
+    model.set_user_input(0, 1, 3, "Gamow").unwrap(); // C1
+    model.set_user_input(0, 2, 1, "=A1").unwrap(); // A2
+    model.set_user_input(0, 2, 2, "=B1").unwrap(); // B2
+    model.set_user_input(0, 2, 3, "=C1").unwrap(); // C2
+
+    // We autofill from A1:C2 to I2
+    model
+        .auto_fill_columns(
+            &Area {
+                sheet: 0,
+                row: 1,
+                column: 1,
+                width: 3,
+                height: 2,
+            },
+            9,
+        )
+        .unwrap();
+
+    // D1
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 4),
+        Ok("Alpher".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 5),
+        Ok("Bethe".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 6),
+        Ok("Gamow".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 7),
+        Ok("Alpher".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 8),
+        Ok("Bethe".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 9),
+        Ok("Gamow".to_string())
+    );
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 2, 4),
+        Ok("Alpher".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 2, 5),
+        Ok("Bethe".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 2, 6),
+        Ok("Gamow".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 2, 7),
+        Ok("Alpher".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 2, 8),
+        Ok("Bethe".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 2, 9),
+        Ok("Gamow".to_string())
+    );
+
+    assert_eq!(model.get_cell_content(0, 2, 4), Ok("=D1".to_string()));
+}
+
+#[test]
+fn styles() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    // cells A1:C1
+    model.set_user_input(0, 1, 1, "Alpher").unwrap();
+    model.set_user_input(0, 2, 1, "Bethe").unwrap();
+    model.set_user_input(0, 3, 1, "Gamow").unwrap();
+
+    let b1 = Area {
+        sheet: 0,
+        row: 1,
+        column: 2,
+        width: 1,
+        height: 1,
+    };
+
+    let c1 = Area {
+        sheet: 0,
+        row: 1,
+        column: 3,
+        width: 1,
+        height: 1,
+    };
+
+    model.update_range_style(&b1, "font.i", "true").unwrap();
+    model
+        .update_range_style(&c1, "fill.bg_color", "#334455")
+        .unwrap();
+
+    model
+        .auto_fill_columns(
+            &Area {
+                sheet: 0,
+                row: 1,
+                column: 1,
+                width: 3,
+                height: 1,
+            },
+            9,
+        )
+        .unwrap();
+
+    // Check that cell E1 has B1 style
+    let style = model.get_cell_style(0, 1, 5).unwrap();
+    assert!(style.font.i);
+    // A6 would have the style of A3
+    let style = model.get_cell_style(0, 1, 6).unwrap();
+    assert_eq!(style.fill.bg_color, Some("#334455".to_string()));
+
+    model.undo().unwrap();
+
+    assert_eq!(model.get_cell_content(0, 1, 4), Ok("".to_string()));
+    // Check that cell A5 has A2 style
+    let style = model.get_cell_style(0, 1, 5).unwrap();
+    assert!(!style.font.i);
+    // A6 would have the style of A3
+    let style = model.get_cell_style(0, 1, 6).unwrap();
+    assert_eq!(style.fill.bg_color, None);
+
+    model.redo().unwrap();
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 4),
+        Ok("Alpher".to_string())
+    );
+    // Check that cell A5 has A2 style
+    let style = model.get_cell_style(0, 1, 5).unwrap();
+    assert!(style.font.i);
+    // A6 would have the style of A3
+    let style = model.get_cell_style(0, 1, 6).unwrap();
+    assert_eq!(style.fill.bg_color, Some("#334455".to_string()));
+}
+
+#[test]
+fn left() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    // cells A10:A12
+    model.set_user_input(0, 1, 10, "Alpher").unwrap();
+    model.set_user_input(0, 1, 11, "Bethe").unwrap();
+    model.set_user_input(0, 1, 12, "Gamow").unwrap();
+
+    // We fill upwards to row 5
+    model
+        .auto_fill_columns(
+            &Area {
+                sheet: 0,
+                row: 1,
+                column: 10,
+                width: 3,
+                height: 1,
+            },
+            5,
+        )
+        .unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 9),
+        Ok("Gamow".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 8),
+        Ok("Bethe".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 7),
+        Ok("Alpher".to_string())
+    );
+}
+
+#[test]
+fn left_4() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    // cells A10:A13
+    model.set_user_input(0, 1, 10, "Margaret Burbidge").unwrap();
+    model.set_user_input(0, 1, 11, "Geoffrey Burbidge").unwrap();
+    model.set_user_input(0, 1, 12, "Willy Fowler").unwrap();
+    model.set_user_input(0, 1, 13, "Fred Hoyle").unwrap();
+
+    // We fill left to row 5
+    model
+        .auto_fill_columns(
+            &Area {
+                sheet: 0,
+                row: 1,
+                column: 10,
+                width: 4,
+                height: 1,
+            },
+            5,
+        )
+        .unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 9),
+        Ok("Fred Hoyle".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 8),
+        Ok("Willy Fowler".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 1, 5),
+        Ok("Fred Hoyle".to_string())
+    );
+}
+
+#[test]
+fn errors() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+
+    model.set_user_input(0, 1, 4, "Margaret Burbidge").unwrap();
+
+    // Invalid sheet
+    assert_eq!(
+        model.auto_fill_columns(
+            &Area {
+                sheet: 3,
+                row: 1,
+                column: 4,
+                width: 1,
+                height: 1,
+            },
+            10,
+        ),
+        Err("Invalid worksheet index: '3'".to_string())
+    );
+
+    // invalid column
+    assert_eq!(
+        model.auto_fill_columns(
+            &Area {
+                sheet: 0,
+                row: 1,
+                column: -1,
+                width: 1,
+                height: 1,
+            },
+            10,
+        ),
+        Err("Invalid column: '-1'".to_string())
+    );
+
+    // invalid column
+    assert_eq!(
+        model.auto_fill_columns(
+            &Area {
+                sheet: 0,
+                row: 1,
+                column: LAST_COLUMN - 1,
+                width: 10,
+                height: 1,
+            },
+            10,
+        ),
+        Err("Invalid column: '16392'".to_string())
+    );
+
+    assert_eq!(
+        model.auto_fill_columns(
+            &Area {
+                sheet: 0,
+                row: LAST_ROW + 1,
+                column: 1,
+                width: 10,
+                height: 1,
+            },
+            10,
+        ),
+        Err("Invalid row: '1048577'".to_string())
+    );
+
+    assert_eq!(
+        model.auto_fill_columns(
+            &Area {
+                sheet: 0,
+                row: LAST_ROW - 2,
+                column: 1,
+                width: 1,
+                height: 10,
+            },
+            10,
+        ),
+        Err("Invalid row: '1048583'".to_string())
+    );
+
+    assert_eq!(
+        model.auto_fill_columns(
+            &Area {
+                sheet: 0,
+                row: 1,
+                column: 5,
+                width: 10,
+                height: 1,
+            },
+            -10,
+        ),
+        Err("Invalid row: '-10'".to_string())
+    );
+}
+
+#[test]
+fn invalid_parameters() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.set_user_input(0, 1, 1, "23").unwrap();
+    assert_eq!(
+        model.auto_fill_columns(
+            &Area {
+                sheet: 0,
+                row: 1,
+                column: 1,
+                width: 2,
+                height: 1,
+            },
+            2,
+        ),
+        Err("Invalid parameters for autofill".to_string())
+    );
+}
--- a/base/src/test/user_model/test_autofill_rows.rs
+++ b/base/src/test/user_model/test_autofill_rows.rs
@@ -0,0 +1,399 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::constants::{LAST_COLUMN, LAST_ROW};
+use crate::expressions::types::Area;
+use crate::test::util::new_empty_model;
+use crate::UserModel;
+
+#[test]
+fn basic_tests() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    // This is cell A3
+    model.set_user_input(0, 3, 1, "alpha").unwrap();
+    // We autofill from A3 to A5
+    model
+        .auto_fill_rows(
+            &Area {
+                sheet: 0,
+                row: 3,
+                column: 1,
+                width: 1,
+                height: 1,
+            },
+            5,
+        )
+        .unwrap();
+    assert_eq!(
+        model.get_formatted_cell_value(0, 4, 1),
+        Ok("alpha".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 5, 1),
+        Ok("alpha".to_string())
+    );
+}
+
+#[test]
+fn one_cell_down() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.set_user_input(0, 1, 1, "23").unwrap();
+    model
+        .auto_fill_rows(
+            &Area {
+                sheet: 0,
+                row: 1,
+                column: 1,
+                width: 1,
+                height: 1,
+            },
+            2,
+        )
+        .unwrap();
+    assert_eq!(
+        model.get_formatted_cell_value(0, 2, 1),
+        Ok("23".to_string())
+    );
+}
+
+#[test]
+fn alpha_beta_gamma() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    // cells A1:B3
+    model.set_user_input(0, 1, 1, "Alpher").unwrap();
+    model.set_user_input(0, 2, 1, "Bethe").unwrap();
+    model.set_user_input(0, 3, 1, "Gamow").unwrap();
+    model.set_user_input(0, 1, 2, "=A1").unwrap();
+    model.set_user_input(0, 2, 2, "=A2").unwrap();
+    model.set_user_input(0, 3, 2, "=A3").unwrap();
+    // We autofill from A1:B3 to A9
+    model
+        .auto_fill_rows(
+            &Area {
+                sheet: 0,
+                row: 1,
+                column: 1,
+                width: 2,
+                height: 3,
+            },
+            9,
+        )
+        .unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 4, 1),
+        Ok("Alpher".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 5, 1),
+        Ok("Bethe".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 6, 1),
+        Ok("Gamow".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 7, 1),
+        Ok("Alpher".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 8, 1),
+        Ok("Bethe".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 9, 1),
+        Ok("Gamow".to_string())
+    );
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 4, 2),
+        Ok("Alpher".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 5, 2),
+        Ok("Bethe".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 6, 2),
+        Ok("Gamow".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 7, 2),
+        Ok("Alpher".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 8, 2),
+        Ok("Bethe".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 9, 2),
+        Ok("Gamow".to_string())
+    );
+
+    assert_eq!(model.get_cell_content(0, 4, 2), Ok("=A4".to_string()));
+}
+
+#[test]
+fn styles() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    // cells A1:B3
+    model.set_user_input(0, 1, 1, "Alpher").unwrap();
+    model.set_user_input(0, 2, 1, "Bethe").unwrap();
+    model.set_user_input(0, 3, 1, "Gamow").unwrap();
+
+    let a2 = Area {
+        sheet: 0,
+        row: 2,
+        column: 1,
+        width: 1,
+        height: 1,
+    };
+
+    let a3 = Area {
+        sheet: 0,
+        row: 3,
+        column: 1,
+        width: 1,
+        height: 1,
+    };
+
+    model.update_range_style(&a2, "font.i", "true").unwrap();
+    model
+        .update_range_style(&a3, "fill.bg_color", "#334455")
+        .unwrap();
+
+    model
+        .auto_fill_rows(
+            &Area {
+                sheet: 0,
+                row: 1,
+                column: 1,
+                width: 1,
+                height: 3,
+            },
+            9,
+        )
+        .unwrap();
+
+    // Check that cell A5 has A2 style
+    let style = model.get_cell_style(0, 5, 1).unwrap();
+    assert!(style.font.i);
+    // A6 would have the style of A3
+    let style = model.get_cell_style(0, 6, 1).unwrap();
+    assert_eq!(style.fill.bg_color, Some("#334455".to_string()));
+
+    model.undo().unwrap();
+
+    assert_eq!(model.get_cell_content(0, 4, 1), Ok("".to_string()));
+    // Check that cell A5 has A2 style
+    let style = model.get_cell_style(0, 5, 1).unwrap();
+    assert!(!style.font.i);
+    // A6 would have the style of A3
+    let style = model.get_cell_style(0, 6, 1).unwrap();
+    assert_eq!(style.fill.bg_color, None);
+
+    model.redo().unwrap();
+    assert_eq!(
+        model.get_formatted_cell_value(0, 4, 1),
+        Ok("Alpher".to_string())
+    );
+    // Check that cell A5 has A2 style
+    let style = model.get_cell_style(0, 5, 1).unwrap();
+    assert!(style.font.i);
+    // A6 would have the style of A3
+    let style = model.get_cell_style(0, 6, 1).unwrap();
+    assert_eq!(style.fill.bg_color, Some("#334455".to_string()));
+}
+
+#[test]
+fn upwards() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    // cells A10:A12
+    model.set_user_input(0, 10, 1, "Alpher").unwrap();
+    model.set_user_input(0, 11, 1, "Bethe").unwrap();
+    model.set_user_input(0, 12, 1, "Gamow").unwrap();
+
+    // We fill upwards to row 5
+    model
+        .auto_fill_rows(
+            &Area {
+                sheet: 0,
+                row: 10,
+                column: 1,
+                width: 1,
+                height: 3,
+            },
+            5,
+        )
+        .unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 9, 1),
+        Ok("Gamow".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 8, 1),
+        Ok("Bethe".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 7, 1),
+        Ok("Alpher".to_string())
+    );
+}
+
+#[test]
+fn upwards_4() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    // cells A10:A13
+    model.set_user_input(0, 10, 1, "Margaret Burbidge").unwrap();
+    model.set_user_input(0, 11, 1, "Geoffrey Burbidge").unwrap();
+    model.set_user_input(0, 12, 1, "Willy Fowler").unwrap();
+    model.set_user_input(0, 13, 1, "Fred Hoyle").unwrap();
+
+    // We fill upwards to row 5
+    model
+        .auto_fill_rows(
+            &Area {
+                sheet: 0,
+                row: 10,
+                column: 1,
+                width: 1,
+                height: 4,
+            },
+            5,
+        )
+        .unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 9, 1),
+        Ok("Fred Hoyle".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 8, 1),
+        Ok("Willy Fowler".to_string())
+    );
+    assert_eq!(
+        model.get_formatted_cell_value(0, 5, 1),
+        Ok("Fred Hoyle".to_string())
+    );
+}
+
+#[test]
+fn errors() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    // cells A10:A13
+    model.set_user_input(0, 4, 1, "Margaret Burbidge").unwrap();
+
+    // Invalid sheet
+    assert_eq!(
+        model.auto_fill_rows(
+            &Area {
+                sheet: 3,
+                row: 4,
+                column: 1,
+                width: 1,
+                height: 1,
+            },
+            10,
+        ),
+        Err("Invalid worksheet index: '3'".to_string())
+    );
+
+    // invalid row
+    assert_eq!(
+        model.auto_fill_rows(
+            &Area {
+                sheet: 0,
+                row: -1,
+                column: 1,
+                width: 1,
+                height: 1,
+            },
+            10,
+        ),
+        Err("Invalid row: '-1'".to_string())
+    );
+
+    // invalid row
+    assert_eq!(
+        model.auto_fill_rows(
+            &Area {
+                sheet: 0,
+                row: LAST_ROW - 1,
+                column: 1,
+                width: 1,
+                height: 10,
+            },
+            10,
+        ),
+        Err("Invalid row: '1048584'".to_string())
+    );
+
+    assert_eq!(
+        model.auto_fill_rows(
+            &Area {
+                sheet: 0,
+                row: 1,
+                column: LAST_COLUMN + 1,
+                width: 1,
+                height: 10,
+            },
+            10,
+        ),
+        Err("Invalid column: '16385'".to_string())
+    );
+
+    assert_eq!(
+        model.auto_fill_rows(
+            &Area {
+                sheet: 0,
+                row: 1,
+                column: LAST_COLUMN - 2,
+                width: 10,
+                height: 1,
+            },
+            10,
+        ),
+        Err("Invalid column: '16391'".to_string())
+    );
+
+    assert_eq!(
+        model.auto_fill_rows(
+            &Area {
+                sheet: 0,
+                row: 5,
+                column: 1,
+                width: 1,
+                height: 10,
+            },
+            -10,
+        ),
+        Err("Invalid row: '-10'".to_string())
+    );
+}
+
+#[test]
+fn invalid_parameters() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.set_user_input(0, 1, 1, "23").unwrap();
+    assert_eq!(
+        model.auto_fill_rows(
+            &Area {
+                sheet: 0,
+                row: 1,
+                column: 1,
+                width: 1,
+                height: 2,
+            },
+            2,
+        ),
+        Err("Invalid parameters for autofill".to_string())
+    );
+}
--- a/base/src/test/user_model/test_border.rs
+++ b/base/src/test/user_model/test_border.rs
@@ -0,0 +1,638 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::{
+    expressions::{types::Area, utils::number_to_column},
+    types::{Border, BorderItem, BorderStyle},
+    BorderArea, UserModel,
+};
+
+#[test]
+fn borders_all() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    // We set an outer border in cells F5:H9
+    let range = &Area {
+        sheet: 0,
+        row: 5,
+        column: 6,
+        width: 3,
+        height: 4,
+    };
+    assert_eq!(number_to_column(6).unwrap(), "F");
+    assert_eq!(number_to_column(8).unwrap(), "H");
+    // ATM we don't have a way to create the object from Rust, that's ok.
+    let border_area: BorderArea = serde_json::from_str(
+        r##"{
+      "item": {
+        "style": "thin",
+        "color": "#FF5566"
+      },
+      "type": "All"
+    }"##,
+    )
+    .unwrap();
+    model.set_area_with_border(range, &border_area).unwrap();
+    for row in 5..9 {
+        for column in 6..9 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let border_item = BorderItem {
+                style: BorderStyle::Thin,
+                color: Some("#FF5566".to_string()),
+            };
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: Some(border_item.clone()),
+                right: Some(border_item.clone()),
+                top: Some(border_item.clone()),
+                bottom: Some(border_item.clone()),
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+    }
+
+    // let's check the borders around
+    {
+        let row = 4;
+        for column in 6..9 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let border_item = BorderItem {
+                style: BorderStyle::Thin,
+                color: Some("#FF5566".to_string()),
+            };
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: None,
+                right: None,
+                top: None,
+                bottom: Some(border_item.clone()),
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+        let row = 9;
+        for column in 6..9 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let border_item = BorderItem {
+                style: BorderStyle::Thin,
+                color: Some("#FF5566".to_string()),
+            };
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: None,
+                right: None,
+                top: Some(border_item.clone()),
+                bottom: None,
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+    }
+    {
+        let column = 5;
+        for row in 5..9 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let border_item = BorderItem {
+                style: BorderStyle::Thin,
+                color: Some("#FF5566".to_string()),
+            };
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: None,
+                right: Some(border_item.clone()),
+                top: None,
+                bottom: None,
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+        let column = 9;
+        for row in 5..9 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let border_item = BorderItem {
+                style: BorderStyle::Thin,
+                color: Some("#FF5566".to_string()),
+            };
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: Some(border_item.clone()),
+                right: None,
+                top: None,
+                bottom: None,
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+    }
+
+    // Lets remove all of them:
+    let border_area: BorderArea = serde_json::from_str(
+        r##"{
+      "item": {
+        "style": "thin",
+        "color": "#FF5566"
+      },
+      "type": "None"
+    }"##,
+    )
+    .unwrap();
+    model.set_area_with_border(range, &border_area).unwrap();
+    for row in 4..10 {
+        for column in 5..10 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: None,
+                right: None,
+                top: None,
+                bottom: None,
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+    }
+}
+
+#[test]
+fn borders_inner() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    // We set an outer border in cells F5:H9
+    let range = &Area {
+        sheet: 0,
+        row: 5,
+        column: 6,
+        width: 3,
+        height: 4,
+    };
+    assert_eq!(number_to_column(6).unwrap(), "F");
+    assert_eq!(number_to_column(8).unwrap(), "H");
+    // ATM we don't have a way to create the object from Rust, that's ok.
+    let border_area: BorderArea = serde_json::from_str(
+        r##"{
+      "item": {
+        "style": "thin",
+        "color": "#FF5566"
+      },
+      "type": "Inner"
+    }"##,
+    )
+    .unwrap();
+    model.set_area_with_border(range, &border_area).unwrap();
+    // The inner part all have borders
+    for row in 6..8 {
+        for column in 7..8 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let border_item = BorderItem {
+                style: BorderStyle::Thin,
+                color: Some("#FF5566".to_string()),
+            };
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: Some(border_item.clone()),
+                right: Some(border_item.clone()),
+                top: Some(border_item.clone()),
+                bottom: Some(border_item.clone()),
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+    }
+    // F5 has border only left and bottom
+    {
+        // We check the border on F5
+        let style = model.get_cell_style(0, 5, 6).unwrap();
+        let border_item = BorderItem {
+            style: BorderStyle::Thin,
+            color: Some("#FF5566".to_string()),
+        };
+        // It should be right and bottom
+        let expected_border = Border {
+            diagonal_up: false,
+            diagonal_down: false,
+            left: None,
+            right: Some(border_item.clone()),
+            top: None,
+            bottom: Some(border_item),
+            diagonal: None,
+        };
+        assert_eq!(style.border, expected_border);
+    }
+    {
+        // Then let's try the bottom-right border
+        let style = model.get_cell_style(0, 8, 8).unwrap();
+        let border_item = BorderItem {
+            style: BorderStyle::Thin,
+            color: Some("#FF5566".to_string()),
+        };
+        // It should be only left and top
+        let expected_border = Border {
+            diagonal_up: false,
+            diagonal_down: false,
+            left: Some(border_item.clone()),
+            right: None,
+            top: Some(border_item.clone()),
+            bottom: None,
+            diagonal: None,
+        };
+        assert_eq!(style.border, expected_border);
+    }
+}
+
+#[test]
+fn borders_outer() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    // We set an outer border in cells F5:H9
+    let range = &Area {
+        sheet: 0,
+        row: 5,
+        column: 6,
+        width: 3,
+        height: 4,
+    };
+    assert_eq!(number_to_column(6).unwrap(), "F");
+    assert_eq!(number_to_column(8).unwrap(), "H");
+    // ATM we don't have a way to create the object from Rust, that's ok.
+    let border_area: BorderArea = serde_json::from_str(
+        r##"{
+      "item": {
+        "style": "thin",
+        "color": "#FF5566"
+      },
+      "type": "Outer"
+    }"##,
+    )
+    .unwrap();
+    model.set_area_with_border(range, &border_area).unwrap();
+    {
+        // We check the border on F5
+        let style = model.get_cell_style(0, 5, 6).unwrap();
+        let border_item = BorderItem {
+            style: BorderStyle::Thin,
+            color: Some("#FF5566".to_string()),
+        };
+        // It should be only left and top
+        let expected_border = Border {
+            diagonal_up: false,
+            diagonal_down: false,
+            left: Some(border_item.clone()),
+            right: None,
+            top: Some(border_item),
+            bottom: None,
+            diagonal: None,
+        };
+        assert_eq!(style.border, expected_border);
+    }
+    {
+        // Then let's try the bottom-right border
+        let style = model.get_cell_style(0, 8, 8).unwrap();
+        let border_item = BorderItem {
+            style: BorderStyle::Thin,
+            color: Some("#FF5566".to_string()),
+        };
+        // It should be only left and top
+        let expected_border = Border {
+            diagonal_up: false,
+            diagonal_down: false,
+            left: None,
+            right: Some(border_item.clone()),
+            top: None,
+            bottom: Some(border_item.clone()),
+            diagonal: None,
+        };
+        assert_eq!(style.border, expected_border);
+    }
+
+    // let's check the borders around
+    {
+        let row = 4;
+        for column in 6..9 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let border_item = BorderItem {
+                style: BorderStyle::Thin,
+                color: Some("#FF5566".to_string()),
+            };
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: None,
+                right: None,
+                top: None,
+                bottom: Some(border_item.clone()),
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+        let row = 9;
+        for column in 6..9 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let border_item = BorderItem {
+                style: BorderStyle::Thin,
+                color: Some("#FF5566".to_string()),
+            };
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: None,
+                right: None,
+                top: Some(border_item.clone()),
+                bottom: None,
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+    }
+    {
+        let column = 5;
+        for row in 5..9 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let border_item = BorderItem {
+                style: BorderStyle::Thin,
+                color: Some("#FF5566".to_string()),
+            };
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: None,
+                right: Some(border_item.clone()),
+                top: None,
+                bottom: None,
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+        let column = 9;
+        for row in 5..9 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let border_item = BorderItem {
+                style: BorderStyle::Thin,
+                color: Some("#FF5566".to_string()),
+            };
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: Some(border_item.clone()),
+                right: None,
+                top: None,
+                bottom: None,
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+    }
+}
+
+#[test]
+fn borders_top() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    // We set an outer border in cells F5:H9
+    let range = &Area {
+        sheet: 0,
+        row: 5,
+        column: 6,
+        width: 3,
+        height: 4,
+    };
+    assert_eq!(number_to_column(6).unwrap(), "F");
+    assert_eq!(number_to_column(8).unwrap(), "H");
+    // ATM we don't have a way to create the object from Rust, that's ok.
+    let border_area: BorderArea = serde_json::from_str(
+        r##"{
+      "item": {
+        "style": "thin",
+        "color": "#FF5566"
+      },
+      "type": "Top"
+    }"##,
+    )
+    .unwrap();
+    model.set_area_with_border(range, &border_area).unwrap();
+    for row in 5..9 {
+        for column in 6..9 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let border_item = BorderItem {
+                style: BorderStyle::Thin,
+                color: Some("#FF5566".to_string()),
+            };
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: None,
+                right: None,
+                top: Some(border_item.clone()),
+                bottom: None,
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+    }
+
+    // let's check the borders around
+    {
+        let row = 4;
+        for column in 6..9 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let border_item = BorderItem {
+                style: BorderStyle::Thin,
+                color: Some("#FF5566".to_string()),
+            };
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: None,
+                right: None,
+                top: None,
+                bottom: Some(border_item.clone()),
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+        let row = 9;
+        for column in 6..9 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: None,
+                right: None,
+                top: None,
+                bottom: None,
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+    }
+    {
+        let column = 5;
+        for row in 5..9 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: None,
+                right: None,
+                top: None,
+                bottom: None,
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+        let column = 9;
+        for row in 5..9 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: None,
+                right: None,
+                top: None,
+                bottom: None,
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+    }
+}
+
+#[test]
+fn borders_right() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    // We set an outer border in cells F5:H9
+    let range = &Area {
+        sheet: 0,
+        row: 5,
+        column: 6,
+        width: 3,
+        height: 4,
+    };
+    assert_eq!(number_to_column(6).unwrap(), "F");
+    assert_eq!(number_to_column(8).unwrap(), "H");
+    // ATM we don't have a way to create the object from Rust, that's ok.
+    let border_area: BorderArea = serde_json::from_str(
+        r##"{
+      "item": {
+        "style": "thin",
+        "color": "#FF5566"
+      },
+      "type": "Right"
+    }"##,
+    )
+    .unwrap();
+    model.set_area_with_border(range, &border_area).unwrap();
+    for row in 5..9 {
+        for column in 6..9 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let border_item = BorderItem {
+                style: BorderStyle::Thin,
+                color: Some("#FF5566".to_string()),
+            };
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: None,
+                right: Some(border_item.clone()),
+                top: None,
+                bottom: None,
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+    }
+}
+
+#[test]
+fn borders_bottom() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    // We set an outer border in cells F5:H9
+    let range = &Area {
+        sheet: 0,
+        row: 5,
+        column: 6,
+        width: 3,
+        height: 4,
+    };
+    assert_eq!(number_to_column(6).unwrap(), "F");
+    assert_eq!(number_to_column(8).unwrap(), "H");
+    // ATM we don't have a way to create the object from Rust, that's ok.
+    let border_area: BorderArea = serde_json::from_str(
+        r##"{
+      "item": {
+        "style": "thin",
+        "color": "#FF5566"
+      },
+      "type": "Bottom"
+    }"##,
+    )
+    .unwrap();
+    model.set_area_with_border(range, &border_area).unwrap();
+    for row in 5..9 {
+        for column in 6..9 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let border_item = BorderItem {
+                style: BorderStyle::Thin,
+                color: Some("#FF5566".to_string()),
+            };
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: None,
+                right: None,
+                top: None,
+                bottom: Some(border_item.clone()),
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+    }
+}
+
+#[test]
+fn borders_left() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    // We set an outer border in cells F5:H9
+    let range = &Area {
+        sheet: 0,
+        row: 5,
+        column: 6,
+        width: 3,
+        height: 4,
+    };
+    assert_eq!(number_to_column(6).unwrap(), "F");
+    assert_eq!(number_to_column(8).unwrap(), "H");
+    // ATM we don't have a way to create the object from Rust, that's ok.
+    let border_area: BorderArea = serde_json::from_str(
+        r##"{
+      "item": {
+        "style": "thin",
+        "color": "#FF5566"
+      },
+      "type": "Left"
+    }"##,
+    )
+    .unwrap();
+    model.set_area_with_border(range, &border_area).unwrap();
+    for row in 5..9 {
+        for column in 6..9 {
+            let style = model.get_cell_style(0, row, column).unwrap();
+            let border_item = BorderItem {
+                style: BorderStyle::Thin,
+                color: Some("#FF5566".to_string()),
+            };
+            let expected_border = Border {
+                diagonal_up: false,
+                diagonal_down: false,
+                left: Some(border_item.clone()),
+                right: None,
+                top: None,
+                bottom: None,
+                diagonal: None,
+            };
+            assert_eq!(style.border, expected_border);
+        }
+    }
+}
--- a/base/src/test/user_model/test_diff_queue.rs
+++ b/base/src/test/user_model/test_diff_queue.rs
@@ -138,7 +138,7 @@ fn queue_undo_redo_multiple() {
 #[test]
 fn new_sheet() {
    let mut model1 = UserModel::from_model(new_empty_model());
-    model1.new_sheet();
+    model1.new_sheet().unwrap();
    model1.set_user_input(0, 1, 1, "42").unwrap();
    model1.set_user_input(1, 1, 1, "=Sheet1!A1*2").unwrap();

--- a/base/src/test/user_model/test_general.rs
+++ b/base/src/test/user_model/test_general.rs
@@ -129,3 +129,12 @@ fn delete_remove_cell() {
    let (sheet, row, column) = (0, 1, 1);
    model.set_user_input(sheet, row, column, "100$").unwrap();
 }
+
+#[test]
+fn get_and_set_name() {
+    let mut model = UserModel::new_empty("MyWorkbook123", "en", "UTC").unwrap();
+    assert_eq!(model.get_name(), "MyWorkbook123");
+
+    model.set_name("Another name");
+    assert_eq!(model.get_name(), "Another name");
+}
--- a/base/src/test/user_model/test_grid_lines.rs
+++ b/base/src/test/user_model/test_grid_lines.rs
@@ -0,0 +1,42 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+use crate::UserModel;
+
+#[test]
+fn basic_tests() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.new_sheet().unwrap();
+
+    // default sheet has show_grid_lines = true
+    assert_eq!(model.get_show_grid_lines(0), Ok(true));
+
+    // default new sheet has show_grid_lines = true
+    assert_eq!(model.get_show_grid_lines(1), Ok(true));
+
+    // wrong sheet number
+    assert_eq!(
+        model.get_show_grid_lines(2),
+        Err("Invalid sheet index".to_string())
+    );
+
+    // we can set it
+    model.set_show_grid_lines(1, false).unwrap();
+    assert_eq!(model.get_show_grid_lines(1), Ok(false));
+    assert_eq!(model.get_show_grid_lines(0), Ok(true));
+
+    model.undo().unwrap();
+
+    assert_eq!(model.get_show_grid_lines(1), Ok(true));
+    assert_eq!(model.get_show_grid_lines(0), Ok(true));
+
+    model.redo().unwrap();
+
+    let send_queue = model.flush_send_queue();
+    let mut model2 = UserModel::from_model(new_empty_model());
+    model2.apply_external_diffs(&send_queue).unwrap();
+
+    assert_eq!(model2.get_show_grid_lines(1), Ok(false));
+    assert_eq!(model2.get_show_grid_lines(0), Ok(true));
+}
--- a/base/src/test/user_model/test_keyboard_navigation.rs
+++ b/base/src/test/user_model/test_keyboard_navigation.rs
@@ -0,0 +1,136 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::{
+    constants::{
+        DEFAULT_COLUMN_WIDTH, DEFAULT_ROW_HEIGHT, DEFAULT_WINDOW_HEIGH, DEFAULT_WINDOW_WIDTH,
+        LAST_COLUMN,
+    },
+    test::util::new_empty_model,
+    UserModel,
+};
+
+#[test]
+fn basic_navigation() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.on_arrow_right().unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.range, [1, 2, 1, 2]);
+    assert_eq!(view.column, 2);
+    assert_eq!(view.row, 1);
+
+    model.on_arrow_left().unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.range, [1, 1, 1, 1]);
+    assert_eq!(view.column, 1);
+    assert_eq!(view.row, 1);
+
+    model.on_arrow_left().unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.range, [1, 1, 1, 1]);
+    assert_eq!(view.column, 1);
+    assert_eq!(view.row, 1);
+
+    model.on_arrow_down().unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.range, [2, 1, 2, 1]);
+    assert_eq!(view.column, 1);
+    assert_eq!(view.row, 2);
+
+    model.on_arrow_up().unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.range, [1, 1, 1, 1]);
+    assert_eq!(view.column, 1);
+    assert_eq!(view.row, 1);
+
+    model.on_arrow_up().unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.range, [1, 1, 1, 1]);
+    assert_eq!(view.column, 1);
+    assert_eq!(view.row, 1);
+}
+
+#[test]
+fn scroll_right() {
+    let window_width = DEFAULT_WINDOW_WIDTH as f64;
+    let column_width = DEFAULT_COLUMN_WIDTH;
+    let column_count = f64::floor(window_width / column_width) as i32;
+
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.on_arrow_right().unwrap();
+
+    model.set_selected_cell(3, column_count).unwrap();
+    model.on_arrow_right().unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.left_column, 2);
+
+    model.on_arrow_right().unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.left_column, 3);
+}
+
+#[test]
+fn last_colum() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.set_selected_cell(3, LAST_COLUMN).unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.column, LAST_COLUMN);
+
+    model.on_arrow_right().unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.column, LAST_COLUMN);
+}
+
+#[test]
+fn page_down() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    let window_height = DEFAULT_WINDOW_HEIGH as f64;
+    let row_height = DEFAULT_ROW_HEIGHT;
+    let row_count = f64::floor(window_height / row_height) as i32;
+    model.on_page_down().unwrap();
+
+    let view = model.get_selected_view();
+    assert_eq!(view.row, 1 + row_count);
+    let scroll_y = model.get_scroll_y().unwrap();
+    assert_eq!(scroll_y, (row_count as f64) * DEFAULT_ROW_HEIGHT);
+}
+
+// we just test that page up and page down are inverse operations
+#[test]
+fn page_up() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.on_page_down().unwrap();
+    let row1 = model.get_selected_view().row;
+
+    model.on_page_down().unwrap();
+    let row2 = model.get_selected_view().row;
+
+    model.on_page_down().unwrap();
+    let row3 = model.get_selected_view().row;
+
+    model.on_page_down().unwrap();
+
+    model.on_page_up().unwrap();
+    assert_eq!(model.get_selected_view().row, row3);
+
+    model.on_page_up().unwrap();
+    assert_eq!(model.get_selected_view().row, row2);
+
+    model.on_page_up().unwrap();
+    assert_eq!(model.get_selected_view().row, row1);
+
+    model.on_page_up().unwrap();
+    assert_eq!(model.get_selected_view().row, 1);
+}
+
+#[test]
+fn page_up_fails_on_row1() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.on_arrow_up().unwrap();
+    assert_eq!(model.get_selected_view().row, 1);
+}
--- a/base/src/test/user_model/test_on_area_selection.rs
+++ b/base/src/test/user_model/test_on_area_selection.rs
@@ -0,0 +1,33 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::{
+    constants::{DEFAULT_COLUMN_WIDTH, DEFAULT_WINDOW_WIDTH},
+    test::util::new_empty_model,
+    UserModel,
+};
+
+#[test]
+fn basic_test() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+
+    model.on_area_selecting(2, 4).unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.range, [1, 1, 2, 4]);
+}
+
+// this checks that is we select in the boundary we automatically scroll
+#[test]
+fn scroll_right() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    let window_width = DEFAULT_WINDOW_WIDTH as f64;
+    let column_width = DEFAULT_COLUMN_WIDTH;
+    let column_count = f64::floor(window_width / column_width) as i32;
+    model.set_selected_cell(3, column_count).unwrap();
+
+    model.on_area_selecting(3, column_count + 3).unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.range, [3, column_count, 3, column_count + 3]);
+    assert_eq!(view.left_column, 4);
+}
--- a/base/src/test/user_model/test_on_expand_selected_range.rs
+++ b/base/src/test/user_model/test_on_expand_selected_range.rs
@@ -0,0 +1,151 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::{
+    constants::{DEFAULT_COLUMN_WIDTH, DEFAULT_WINDOW_WIDTH, LAST_COLUMN},
+    test::util::new_empty_model,
+    UserModel,
+};
+
+#[test]
+fn arrow_right() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.on_expand_selected_range("ArrowRight").unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.range, [1, 1, 1, 2]);
+}
+
+#[test]
+fn arrow_right_decreases() {
+    // if the selected cell is on the upper right corner, right-arrow will decrease the size of teh area
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    let (start_row, start_column, end_row, end_column) = (5, 3, 10, 8);
+    model.set_selected_cell(start_row, end_column).unwrap();
+    model
+        .set_selected_range(start_row, start_column, end_row, end_column)
+        .unwrap();
+
+    model.on_expand_selected_range("ArrowRight").unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(
+        view.range,
+        [start_row, start_column + 1, end_row, end_column]
+    );
+}
+
+#[test]
+fn arrow_right_last_column() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.set_selected_cell(1, LAST_COLUMN).unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.range, [1, LAST_COLUMN, 1, LAST_COLUMN]);
+}
+
+#[test]
+fn arrow_right_scroll_right() {
+    let window_width = DEFAULT_WINDOW_WIDTH as f64;
+    let column_width = DEFAULT_COLUMN_WIDTH;
+    let column_count = f64::floor(window_width / column_width) as i32;
+
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+
+    // initially the column to the left is A
+    let view = model.get_selected_view();
+    assert_eq!(view.left_column, 1);
+
+    // We select all columns from 1 to the last visible
+    let (start_row, start_column, end_row, end_column) = (1, 1, 1, column_count);
+    model.set_selected_cell(start_row, start_column).unwrap();
+    model
+        .set_selected_range(start_row, start_column, end_row, end_column)
+        .unwrap();
+
+    // Now we select one more column
+    model.on_expand_selected_range("ArrowRight").unwrap();
+
+    // The view has updated and the first visible column is B
+    let view = model.get_selected_view();
+    assert_eq!(
+        view.range,
+        [start_row, start_column, end_row, end_column + 1]
+    );
+    assert_eq!(view.left_column, 2);
+
+    // now we click on cell B2 and we
+    model.set_selected_cell(2, 2).unwrap();
+    model.on_expand_selected_range("ArrowLeft").unwrap();
+
+    let view = model.get_selected_view();
+    assert_eq!(view.range, [2, 1, 2, 2]);
+    assert_eq!(view.left_column, 1);
+
+    // a second arrow left won't do anything
+    model.on_expand_selected_range("ArrowLeft").unwrap();
+
+    let view = model.get_selected_view();
+    assert_eq!(view.range, [2, 1, 2, 2]);
+    assert_eq!(view.left_column, 1);
+}
+
+#[test]
+fn arrow_left() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.set_selected_cell(5, 3).unwrap();
+    model.set_selected_range(5, 3, 10, 8).unwrap();
+    model.on_expand_selected_range("ArrowLeft").unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.range, [5, 3, 10, 7]);
+}
+
+#[test]
+fn arrow_left_left_border() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.on_expand_selected_range("ArrowLeft").unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(view.range, [1, 1, 1, 1]);
+}
+
+#[test]
+fn arrow_left_increases() {
+    // If the selected cell is on the top right corner
+    // arrow left increases the selected area by
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+
+    let (start_row, start_column, end_row, end_column) = (4, 10, 4, 20);
+    model.set_selected_cell(start_row, end_column).unwrap();
+    model
+        .set_selected_range(start_row, start_column, end_row, end_column)
+        .unwrap();
+    model.on_expand_selected_range("ArrowLeft").unwrap();
+    let view = model.get_selected_view();
+    assert_eq!(
+        view.range,
+        [start_row, start_column - 1, end_row, end_column]
+    );
+}
+
+#[test]
+fn arrow_left_scrolls_left() {
+    // If the selected cell is on the top right corner
+    // arrow left increases the selected area by
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+
+    model.set_top_left_visible_cell(1, 50).unwrap();
+
+    model.set_selected_cell(1, 50).unwrap();
+    // arrow left x 2
+    model.on_expand_selected_range("ArrowLeft").unwrap();
+    model.on_expand_selected_range("ArrowLeft").unwrap();
+
+    let view = model.get_selected_view();
+    assert_eq!(view.range, [1, 48, 1, 50]);
+    assert_eq!(view.left_column, 48);
+    assert_eq!(view.column, 50);
+}
--- a/base/src/test/user_model/test_on_paste_styles.rs
+++ b/base/src/test/user_model/test_on_paste_styles.rs
@@ -0,0 +1,48 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::test::util::new_empty_model;
+use crate::types::Fill;
+use crate::UserModel;
+
+#[test]
+fn simple_pasting() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    let mut style = model.get_cell_style(0, 1, 1).unwrap();
+    style.fill = Fill {
+        pattern_type: "solid".to_string(),
+        fg_color: Some("#FF5577".to_string()),
+        bg_color: Some("#33FF44".to_string()),
+    };
+    let styles = vec![vec![style.clone()]];
+
+    model.set_selected_cell(5, 4).unwrap();
+    model.set_selected_range(5, 4, 10, 9).unwrap();
+    model.on_paste_styles(&styles).unwrap();
+
+    for row in 5..10 {
+        for column in 4..9 {
+            let cell_style = model.get_cell_style(0, row, column).unwrap();
+            assert_eq!(cell_style, style);
+        }
+    }
+
+    model.undo().unwrap();
+    let base_style = model.get_cell_style(0, 100, 100).unwrap();
+
+    for row in 5..10 {
+        for column in 4..9 {
+            let cell_style = model.get_cell_style(0, row, column).unwrap();
+            assert_eq!(cell_style, base_style);
+        }
+    }
+
+    model.redo().unwrap();
+
+    for row in 5..10 {
+        for column in 4..9 {
+            let cell_style = model.get_cell_style(0, row, column).unwrap();
+            assert_eq!(cell_style, style);
+        }
+    }
+}
--- a/base/src/test/user_model/test_paste_csv.rs
+++ b/base/src/test/user_model/test_paste_csv.rs
@@ -0,0 +1,164 @@
+use crate::{expressions::types::Area, UserModel};
+
+#[test]
+fn csv_paste() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 7, 7, "=SUM(B4:D7)").unwrap();
+    assert_eq!(model.get_formatted_cell_value(0, 7, 7), Ok("0".to_string()));
+
+    // paste some numbers in B4:C7
+    let csv = "1,2,3\n4,5,6";
+    let area = Area {
+        sheet: 0,
+        row: 4,
+        column: 2,
+        width: 1,
+        height: 1,
+    };
+    model.set_selected_cell(4, 2).unwrap();
+    model.paste_csv_string(&area, csv).unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 7, 7),
+        Ok("21".to_string())
+    );
+}
+
+#[test]
+fn tsv_crlf_paste() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 7, 7, "=SUM(B4:D7)").unwrap();
+    assert_eq!(model.get_formatted_cell_value(0, 7, 7), Ok("0".to_string()));
+
+    // paste some numbers in B4:C7
+    let csv = "1\t2\t3\r\n4\t5\t6";
+    let area = Area {
+        sheet: 0,
+        row: 4,
+        column: 2,
+        width: 1,
+        height: 1,
+    };
+    model.set_selected_cell(4, 2).unwrap();
+    model.paste_csv_string(&area, csv).unwrap();
+
+    assert_eq!(
+        model.get_formatted_cell_value(0, 7, 7),
+        Ok("21".to_string())
+    );
+}
+
+#[test]
+fn cut_paste() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "42").unwrap();
+    model.set_user_input(0, 1, 2, "=A1*3+1").unwrap();
+
+    // set A1 bold
+    let range = Area {
+        sheet: 0,
+        row: 1,
+        column: 1,
+        width: 1,
+        height: 1,
+    };
+    model.update_range_style(&range, "font.b", "true").unwrap();
+
+    model
+        .set_user_input(0, 2, 1, "A season of faith, \"perfection\"")
+        .unwrap();
+
+    // Select A1:B2 and copy
+    model.set_selected_range(1, 1, 2, 2).unwrap();
+    let copy = model.copy_to_clipboard().unwrap();
+
+    model.set_selected_cell(4, 4).unwrap();
+
+    // paste in cell D4 (4, 4)
+    model
+        .paste_from_clipboard((1, 1, 2, 2), &copy.data, true)
+        .unwrap();
+
+    assert_eq!(model.get_cell_content(0, 4, 4), Ok("42".to_string()));
+    assert_eq!(model.get_cell_content(0, 4, 5), Ok("=D4*3+1".to_string()));
+    assert_eq!(
+        model.get_formatted_cell_value(0, 4, 5),
+        Ok("127".to_string())
+    );
+    // cell D4 must be bold
+    let style_d4 = model.get_cell_style(0, 4, 4).unwrap();
+    assert!(style_d4.font.b);
+
+    // range A1:B2 must be empty
+    assert_eq!(model.get_cell_content(0, 1, 1), Ok("".to_string()));
+    assert_eq!(model.get_cell_content(0, 1, 2), Ok("".to_string()));
+    assert_eq!(model.get_cell_content(0, 2, 1), Ok("".to_string()));
+    assert_eq!(model.get_cell_content(0, 2, 2), Ok("".to_string()));
+}
+
+#[test]
+fn copy_paste_internal() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.set_user_input(0, 1, 1, "42").unwrap();
+    model.set_user_input(0, 1, 2, "=A1*3+1").unwrap();
+
+    // set A1 bold
+    let range = Area {
+        sheet: 0,
+        row: 1,
+        column: 1,
+        width: 1,
+        height: 1,
+    };
+    model.update_range_style(&range, "font.b", "true").unwrap();
+
+    model
+        .set_user_input(0, 2, 1, "A season of faith, \"perfection\"")
+        .unwrap();
+
+    // Select A1:B2 and copy
+    model.set_selected_range(1, 1, 2, 2).unwrap();
+    let copy = model.copy_to_clipboard().unwrap();
+    assert_eq!(
+        copy.csv,
+        "42,127\n\"A season of faith, \"\"perfection\"\"\",\n"
+    );
+    assert_eq!(copy.range, (1, 1, 2, 2));
+
+    model.set_selected_cell(4, 4).unwrap();
+
+    // paste in cell D4 (4, 4)
+    model
+        .paste_from_clipboard((1, 1, 2, 2), &copy.data, false)
+        .unwrap();
+
+    assert_eq!(model.get_cell_content(0, 4, 4), Ok("42".to_string()));
+    assert_eq!(model.get_cell_content(0, 4, 5), Ok("=D4*3+1".to_string()));
+    assert_eq!(
+        model.get_formatted_cell_value(0, 4, 5),
+        Ok("127".to_string())
+    );
+    // cell D4 must be bold
+    let style_d4 = model.get_cell_style(0, 4, 4).unwrap();
+    assert!(style_d4.font.b);
+
+    model.undo().unwrap();
+
+    assert_eq!(model.get_cell_content(0, 4, 4), Ok("".to_string()));
+    assert_eq!(model.get_cell_content(0, 4, 5), Ok("".to_string()));
+    // cell D4 must not be bold
+    let style_d4 = model.get_cell_style(0, 4, 4).unwrap();
+    assert!(!style_d4.font.b);
+
+    model.redo().unwrap();
+
+    assert_eq!(model.get_cell_content(0, 4, 4), Ok("42".to_string()));
+    assert_eq!(model.get_cell_content(0, 4, 5), Ok("=D4*3+1".to_string()));
+    assert_eq!(
+        model.get_formatted_cell_value(0, 4, 5),
+        Ok("127".to_string())
+    );
+    // cell D4 must be bold
+    let style_d4 = model.get_cell_style(0, 4, 4).unwrap();
+    assert!(style_d4.font.b);
+}
--- a/base/src/test/user_model/test_rename_sheet.rs
+++ b/base/src/test/user_model/test_rename_sheet.rs
@@ -9,6 +9,13 @@ fn basic_rename() {
    assert_eq!(model.get_worksheets_properties()[0].name, "NewSheet");
 }

+#[test]
+fn rename_with_same_name() {
+    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
+    model.rename_sheet(0, "Sheet1").unwrap();
+    assert_eq!(model.get_worksheets_properties()[0].name, "Sheet1");
+}
+
 #[test]
 fn undo_redo() {
    let mut model = UserModel::new_empty("model", "en", "UTC").unwrap();
--- a/base/src/test/user_model/test_row_column.rs
+++ b/base/src/test/user_model/test_row_column.rs
@@ -154,3 +154,21 @@ fn simple_delete_row_no_style() {

    assert_eq!(model.get_formatted_cell_value(0, 15, 6), Ok("".to_string()));
 }
+
+#[test]
+fn row_heigh_increases_automatically() {
+    let mut model = UserModel::new_empty("Workbook1", "en", "UTC").unwrap();
+    assert_eq!(model.get_row_height(0, 1), Ok(DEFAULT_ROW_HEIGHT));
+
+    // Entering a single line does not change the height
+    model
+        .set_user_input(0, 1, 1, "My home in Canada had horses")
+        .unwrap();
+    assert_eq!(model.get_row_height(0, 1), Ok(DEFAULT_ROW_HEIGHT));
+
+    // entering a two liner does:
+    model
+        .set_user_input(0, 1, 1, "My home in Canada had horses\nAnd monkeys!")
+        .unwrap();
+    assert_eq!(model.get_row_height(0, 1), Ok(2.0 * DEFAULT_ROW_HEIGHT));
+}
--- a/base/src/test/user_model/test_styles.rs
+++ b/base/src/test/user_model/test_styles.rs
@@ -144,13 +144,20 @@ fn basic_fill() {

    let style = model.get_cell_style(0, 1, 1).unwrap();
    assert_eq!(style.fill.bg_color, None);
+    assert_eq!(style.fill.fg_color, None);
+    assert_eq!(&style.fill.pattern_type, "none");

    // bg_color
    model
        .update_range_style(&range, "fill.bg_color", "#F2F2F2")
        .unwrap();
+    model
+        .update_range_style(&range, "fill.fg_color", "#F3F4F5")
+        .unwrap();
    let style = model.get_cell_style(0, 1, 1).unwrap();
    assert_eq!(style.fill.bg_color, Some("#F2F2F2".to_owned()));
+    assert_eq!(style.fill.fg_color, Some("#F3F4F5".to_owned()));
+    assert_eq!(&style.fill.pattern_type, "solid");

    let send_queue = model.flush_send_queue();

@@ -159,6 +166,7 @@ fn basic_fill() {

    let style = model2.get_cell_style(0, 1, 1).unwrap();
    assert_eq!(style.fill.bg_color, Some("#F2F2F2".to_owned()));
+    assert_eq!(style.fill.fg_color, Some("#F3F4F5".to_owned()));
 }

 #[test]
@@ -171,9 +179,15 @@ fn fill_errors() {
        width: 1,
        height: 1,
    };
-    assert!(model
-        .update_range_style(&range, "fill.bg_color", "#FFF")
-        .is_err());
+    assert_eq!(
+        model.update_range_style(&range, "fill.bg_color", "#FFF"),
+        Err("Invalid color: '#FFF'.".to_string())
+    );
+
+    assert_eq!(
+        model.update_range_style(&range, "fill.fg_color", "#FFF"),
+        Err("Invalid color: '#FFF'.".to_string())
+    );
 }

 #[test]
--- a/base/src/test/user_model/test_view.rs
+++ b/base/src/test/user_model/test_view.rs
@@ -0,0 +1,209 @@
+#![allow(clippy::unwrap_used)]
+
+use std::collections::HashMap;
+
+use crate::{
+    constants::{LAST_COLUMN, LAST_ROW},
+    test::util::new_empty_model,
+    user_model::SelectedView,
+    UserModel,
+};
+
+#[test]
+fn initial_view() {
+    let model = new_empty_model();
+    let model = UserModel::from_model(model);
+    assert_eq!(model.get_selected_sheet(), 0);
+    assert_eq!(model.get_selected_cell(), (0, 1, 1));
+    assert_eq!(
+        model.get_selected_view(),
+        SelectedView {
+            sheet: 0,
+            row: 1,
+            column: 1,
+            range: [1, 1, 1, 1],
+            top_row: 1,
+            left_column: 1
+        }
+    );
+}
+
+#[test]
+fn set_the_cell_sets_the_range() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.set_selected_cell(5, 4).unwrap();
+    assert_eq!(model.get_selected_sheet(), 0);
+    assert_eq!(model.get_selected_cell(), (0, 5, 4));
+    assert_eq!(
+        model.get_selected_view(),
+        SelectedView {
+            sheet: 0,
+            row: 5,
+            column: 4,
+            range: [5, 4, 5, 4],
+            top_row: 1,
+            left_column: 1
+        }
+    );
+}
+
+#[test]
+fn set_the_range_does_not_set_the_cell() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    assert_eq!(
+        model.set_selected_range(5, 4, 10, 6),
+        Err(
+            "The selected cells is not in one of the corners. Row: '1' and row range '(5, 10)'"
+                .to_string()
+        )
+    );
+}
+
+#[test]
+fn add_new_sheet_and_back() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.new_sheet().unwrap();
+    assert_eq!(model.get_selected_sheet(), 1);
+    model.set_selected_cell(5, 4).unwrap();
+    model.set_selected_sheet(0).unwrap();
+    assert_eq!(model.get_selected_cell(), (0, 1, 1));
+    model.set_selected_sheet(1).unwrap();
+    assert_eq!(model.get_selected_cell(), (1, 5, 4));
+}
+
+#[test]
+fn set_selected_cell_errors() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    assert_eq!(
+        model.set_selected_cell(-5, 4),
+        Err("Invalid row: '-5'".to_string())
+    );
+    assert_eq!(
+        model.set_selected_cell(5, -4),
+        Err("Invalid column: '-4'".to_string())
+    );
+    assert_eq!(
+        model.set_selected_range(-1, 1, 1, 1),
+        Err("Invalid row: '-1'".to_string())
+    );
+    assert_eq!(
+        model.set_selected_range(1, 0, 1, 1),
+        Err("Invalid column: '0'".to_string())
+    );
+    assert_eq!(
+        model.set_selected_range(1, 1, LAST_ROW + 1, 1),
+        Err("Invalid row: '1048577'".to_string())
+    );
+    assert_eq!(
+        model.set_selected_range(1, 1, 1, LAST_COLUMN + 1),
+        Err("Invalid column: '16385'".to_string())
+    );
+}
+
+#[test]
+fn set_selected_cell_errors_wrong_sheet() {
+    let mut model = new_empty_model();
+    // forcefully set a wrong index
+    model.workbook.views.get_mut(&0).unwrap().sheet = 2;
+    let mut model = UserModel::from_model(model);
+    // It's returning the wrong number
+    assert_eq!(model.get_selected_sheet(), 2);
+
+    // But we can't set the selected cell anymore
+    assert_eq!(
+        model.set_selected_cell(3, 4),
+        Err("Invalid worksheet index 2".to_string())
+    );
+    assert_eq!(
+        model.set_selected_range(3, 4, 5, 6),
+        Err("Invalid worksheet index 2".to_string())
+    );
+
+    assert_eq!(
+        model.set_top_left_visible_cell(3, 4),
+        Err("Invalid worksheet index 2".to_string())
+    );
+
+    // we can fix it by setting the right cell
+    model.set_selected_sheet(0).unwrap();
+    model.set_selected_cell(3, 4).unwrap();
+}
+
+#[test]
+fn set_visible_cell() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    model.set_top_left_visible_cell(100, 12).unwrap();
+
+    assert_eq!(
+        model.get_selected_view(),
+        SelectedView {
+            sheet: 0,
+            row: 1,
+            column: 1,
+            range: [1, 1, 1, 1],
+            top_row: 100,
+            left_column: 12
+        }
+    );
+
+    let s = serde_json::to_string(&model.get_selected_view()).unwrap();
+    assert_eq!(
+        serde_json::from_str::<SelectedView>(&s).unwrap(),
+        SelectedView {
+            sheet: 0,
+            row: 1,
+            column: 1,
+            range: [1, 1, 1, 1],
+            top_row: 100,
+            left_column: 12
+        }
+    );
+}
+
+#[test]
+fn set_visible_cell_errors() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    assert_eq!(
+        model.set_top_left_visible_cell(-100, 12),
+        Err("Invalid row: '-100'".to_string())
+    );
+    assert_eq!(
+        model.set_top_left_visible_cell(100, -12),
+        Err("Invalid column: '-12'".to_string())
+    );
+}
+
+#[test]
+fn errors_no_views() {
+    let mut model = new_empty_model();
+    // forcefully remove the view
+    model.workbook.views = HashMap::new();
+    // also in the sheet
+    model.workbook.worksheets[0].views = HashMap::new();
+    let mut model = UserModel::from_model(model);
+    // get methods will return defaults
+    assert_eq!(model.get_selected_sheet(), 0);
+    assert_eq!(model.get_selected_cell(), (0, 1, 1));
+    assert_eq!(
+        model.get_selected_view(),
+        SelectedView {
+            sheet: 0,
+            row: 1,
+            column: 1,
+            range: [1, 1, 1, 1],
+            top_row: 1,
+            left_column: 1
+        }
+    );
+
+    // set methods won't complain. but won't work either
+    model.set_selected_sheet(0).unwrap();
+    model.set_selected_cell(5, 6).unwrap();
+    assert_eq!(model.get_selected_cell(), (0, 1, 1));
+}
--- a/base/src/test/user_model/test_window_size.rs
+++ b/base/src/test/user_model/test_window_size.rs
@@ -0,0 +1,29 @@
+#![allow(clippy::unwrap_used)]
+
+use crate::{
+    constants::{DEFAULT_ROW_HEIGHT, DEFAULT_WINDOW_HEIGH, DEFAULT_WINDOW_WIDTH},
+    test::util::new_empty_model,
+    UserModel,
+};
+
+#[test]
+fn basic_test() {
+    let model = new_empty_model();
+    let mut model = UserModel::from_model(model);
+    let window_height = model.get_window_height().unwrap();
+    assert_eq!(window_height, DEFAULT_WINDOW_HEIGH);
+
+    let window_width = model.get_window_width().unwrap();
+    assert_eq!(window_width, DEFAULT_WINDOW_WIDTH);
+
+    // Set the window height to double the default and check that page_down behaves as expected
+    model.set_window_height((window_height * 2) as f64);
+    model.on_page_down().unwrap();
+
+    let row_height = DEFAULT_ROW_HEIGHT;
+    let row_count = f64::floor((window_height * 2) as f64 / row_height) as i32;
+    let view = model.get_selected_view();
+    assert_eq!(view.row, 1 + row_count);
+    let scroll_y = model.get_scroll_y().unwrap();
+    assert_eq!(scroll_y, (row_count as f64) * DEFAULT_ROW_HEIGHT);
+}
--- a/base/src/test/util.rs
+++ b/base/src/test/util.rs
@@ -20,7 +20,8 @@ impl Model {
        let cell_reference = self._parse_reference(cell);
        let column = cell_reference.column;
        let row = cell_reference.row;
-        self.set_user_input(cell_reference.sheet, row, column, value.to_string());
+        self.set_user_input(cell_reference.sheet, row, column, value.to_string())
+            .unwrap();
    }
    pub fn _has_formula(&self, cell: &str) -> bool {
        self._get_formula_opt(cell).is_some()
--- a/base/src/types.rs
+++ b/base/src/types.rs
@@ -4,37 +4,15 @@ use std::{collections::HashMap, fmt::Display};

 use crate::expressions::token::Error;

-// Useful for `#[serde(default = "default_as_true")]`
-fn default_as_true() -> bool {
-    true
-}
-
 fn default_as_false() -> bool {
    false
 }

-// Useful for `#[serde(skip_serializing_if = "is_true")]`
-fn is_true(b: &bool) -> bool {
-    *b
-}
-
 fn is_false(b: &bool) -> bool {
    !*b
 }

-fn is_zero(num: &i32) -> bool {
-    *num == 0
-}
-
-fn is_default_alignment(o: &Option<Alignment>) -> bool {
-    o.is_none() || *o == Some(Alignment::default())
-}
-
-fn hashmap_is_empty(h: &HashMap<String, Table>) -> bool {
-    h.values().len() == 0
-}
-
-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
 pub struct Metadata {
    pub application: String,
    pub app_version: String,
@@ -44,14 +22,25 @@ pub struct Metadata {
    pub last_modified: String, //"2020-11-20T16:24:35"
 }

-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
 pub struct WorkbookSettings {
    pub tz: String,
    pub locale: String,
 }
+
+/// A Workbook View tracks of the selected sheet for each view
+#[derive(Encode, Decode, Debug, PartialEq, Clone)]
+pub struct WorkbookView {
+    /// The index of the currently selected sheet.
+    pub sheet: u32,
+    /// The current width of the window
+    pub window_width: i64,
+    /// The current heigh of the window
+    pub window_height: i64,
+}
+
 /// An internal representation of an IronCalc Workbook
-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Clone)]
-#[serde(deny_unknown_fields)]
+#[derive(Encode, Decode, Debug, PartialEq, Clone)]
 pub struct Workbook {
    pub shared_strings: Vec<String>,
    pub defined_names: Vec<DefinedName>,
@@ -60,28 +49,22 @@ pub struct Workbook {
    pub name: String,
    pub settings: WorkbookSettings,
    pub metadata: Metadata,
-    #[serde(default)]
-    #[serde(skip_serializing_if = "hashmap_is_empty")]
    pub tables: HashMap<String, Table>,
+    pub views: HashMap<u32, WorkbookView>,
 }

 /// A defined name. The `sheet_id` is the sheet index in case the name is local
-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
 pub struct DefinedName {
    pub name: String,
    pub formula: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
    pub sheet_id: Option<u32>,
 }

-// TODO: Move to worksheet.rs make frozen_rows/columns private and u32
-/// Internal representation of a worksheet Excel object
-
 /// * state:
 ///    18.18.68 ST_SheetState (Sheet Visibility Types)
 ///    hidden, veryHidden, visible
-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
-#[serde(rename_all = "lowercase")]
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
 pub enum SheetState {
    Visible,
    Hidden,
@@ -98,8 +81,25 @@ impl Display for SheetState {
    }
 }

+/// Represents the state of the worksheet as seen by the user. This includes
+/// details such as the currently selected cell, the visible range, and the
+/// position of the viewport.
+#[derive(Encode, Decode, Debug, PartialEq, Clone)]
+pub struct WorksheetView {
+    /// The row index of the currently selected cell.
+    pub row: i32,
+    /// The column index of the currently selected cell.
+    pub column: i32,
+    /// The selected range in the worksheet, specified as [start_row, start_column, end_row, end_column].
+    pub range: [i32; 4],
+    /// The row index of the topmost visible cell in the worksheet view.
+    pub top_row: i32,
+    /// The column index of the leftmost visible cell in the worksheet view.
+    pub left_column: i32,
+}
+
 /// Internal representation of a worksheet Excel object
-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Clone)]
+#[derive(Encode, Decode, Debug, PartialEq, Clone)]
 pub struct Worksheet {
    pub dimension: String,
    pub cols: Vec<Col>,
@@ -109,16 +109,14 @@ pub struct Worksheet {
    pub shared_formulas: Vec<String>,
    pub sheet_id: u32,
    pub state: SheetState,
-    #[serde(skip_serializing_if = "Option::is_none")]
    pub color: Option<String>,
    pub merge_cells: Vec<String>,
    pub comments: Vec<Comment>,
-    #[serde(default)]
-    #[serde(skip_serializing_if = "is_zero")]
    pub frozen_rows: i32,
-    #[serde(default)]
-    #[serde(skip_serializing_if = "is_zero")]
    pub frozen_columns: i32,
+    pub views: HashMap<u32, WorksheetView>,
+    /// Whether or not to show the grid lines in the worksheet
+    pub show_grid_lines: bool,
 }

 /// Internal representation of Excel's sheet_data
@@ -126,7 +124,7 @@ pub struct Worksheet {
 pub type SheetData = HashMap<i32, HashMap<i32, Cell>>;

 // ECMA-376-1:2016 section 18.3.1.73
-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Clone)]
+#[derive(Encode, Decode, Debug, PartialEq, Clone)]
 pub struct Row {
    /// Row index
    pub r: i32,
@@ -134,23 +132,19 @@ pub struct Row {
    pub custom_format: bool,
    pub custom_height: bool,
    pub s: i32,
-    #[serde(default = "default_as_false")]
-    #[serde(skip_serializing_if = "is_false")]
    pub hidden: bool,
 }

 // ECMA-376-1:2016 section 18.3.1.13
-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Clone)]
+#[derive(Encode, Decode, Debug, PartialEq, Clone)]
 pub struct Col {
    // Column definitions are defined on ranges, unlike rows which store unique, per-row entries.
    /// First column affected by this record. Settings apply to column in \[min, max\] range.
    pub min: i32,
    /// Last column affected by this record. Settings apply to column in \[min, max\] range.
    pub max: i32,
-
    pub width: f64,
    pub custom_width: bool,
-    #[serde(skip_serializing_if = "Option::is_none")]
    pub style: Option<i32>,
 }

@@ -165,32 +159,55 @@ pub enum CellType {
    CompoundData = 128,
 }

-#[derive(Serialize, Deserialize, Encode, Decode, Debug, Clone, PartialEq)]
-#[serde(tag = "t", deny_unknown_fields)]
+#[derive(Encode, Decode, Debug, Clone, PartialEq)]
 pub enum Cell {
-    #[serde(rename = "empty")]
-    EmptyCell { s: i32 },
-    #[serde(rename = "b")]
-    BooleanCell { v: bool, s: i32 },
-    #[serde(rename = "n")]
-    NumberCell { v: f64, s: i32 },
+    EmptyCell {
+        s: i32,
+    },
+
+    BooleanCell {
+        v: bool,
+        s: i32,
+    },
+
+    NumberCell {
+        v: f64,
+        s: i32,
+    },
    // Maybe we should not have this type. In Excel this is just a string
-    #[serde(rename = "e")]
-    ErrorCell { ei: Error, s: i32 },
+    ErrorCell {
+        ei: Error,
+        s: i32,
+    },
    // Always a shared string
-    #[serde(rename = "s")]
-    SharedString { si: i32, s: i32 },
+    SharedString {
+        si: i32,
+        s: i32,
+    },
    // Non evaluated Formula
-    #[serde(rename = "u")]
-    CellFormula { f: i32, s: i32 },
-    #[serde(rename = "fb")]
-    CellFormulaBoolean { f: i32, v: bool, s: i32 },
-    #[serde(rename = "fn")]
-    CellFormulaNumber { f: i32, v: f64, s: i32 },
+    CellFormula {
+        f: i32,
+        s: i32,
+    },
+
+    CellFormulaBoolean {
+        f: i32,
+        v: bool,
+        s: i32,
+    },
+
+    CellFormulaNumber {
+        f: i32,
+        v: f64,
+        s: i32,
+    },
    // always inline string
-    #[serde(rename = "str")]
-    CellFormulaString { f: i32, v: String, s: i32 },
-    #[serde(rename = "fe")]
+    CellFormulaString {
+        f: i32,
+        v: String,
+        s: i32,
+    },
+
    CellFormulaError {
        f: i32,
        ei: Error,
@@ -209,17 +226,16 @@ impl Default for Cell {
    }
 }

-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
 pub struct Comment {
    pub text: String,
    pub author_name: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
    pub author_id: Option<String>,
    pub cell_ref: String,
 }

 // ECMA-376-1:2016 section 18.5.1.2
-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
 pub struct Table {
    pub name: String,
    pub display_name: String,
@@ -227,34 +243,24 @@ pub struct Table {
    pub reference: String,
    pub totals_row_count: u32,
    pub header_row_count: u32,
-    #[serde(skip_serializing_if = "Option::is_none")]
    pub header_row_dxf_id: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
    pub data_dxf_id: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
    pub totals_row_dxf_id: Option<u32>,
    pub columns: Vec<TableColumn>,
    pub style_info: TableStyleInfo,
-    #[serde(default = "default_as_false")]
-    #[serde(skip_serializing_if = "is_false")]
    pub has_filters: bool,
 }

 // totals_row_label vs totals_row_function might be mutually exclusive. Use an enum?
 // the totals_row_function is an enum not String methinks
-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
 pub struct TableColumn {
    pub id: u32,
    pub name: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
    pub totals_row_label: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
    pub header_row_dxf_id: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
    pub data_dxf_id: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
    pub totals_row_dxf_id: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
    pub totals_row_function: Option<String>,
 }

@@ -272,25 +278,16 @@ impl Default for TableColumn {
    }
 }

-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone, Default)]
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone, Default)]
 pub struct TableStyleInfo {
-    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
-    #[serde(default = "default_as_false")]
-    #[serde(skip_serializing_if = "is_false")]
    pub show_first_column: bool,
-    #[serde(default = "default_as_false")]
-    #[serde(skip_serializing_if = "is_false")]
    pub show_last_column: bool,
-    #[serde(default = "default_as_false")]
-    #[serde(skip_serializing_if = "is_false")]
    pub show_row_stripes: bool,
-    #[serde(default = "default_as_false")]
-    #[serde(skip_serializing_if = "is_false")]
    pub show_column_stripes: bool,
 }

-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
 pub struct Styles {
    pub num_fmts: Vec<NumFmt>,
    pub fonts: Vec<Font>,
@@ -326,7 +323,7 @@ pub struct Style {
    pub quote_prefix: bool,
 }

-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
 pub struct NumFmt {
    pub num_fmt_id: i32,
    pub format_code: String,
@@ -516,29 +513,17 @@ pub struct Alignment {
    pub wrap_text: bool,
 }

-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
 pub struct CellStyleXfs {
    pub num_fmt_id: i32,
    pub font_id: i32,
    pub fill_id: i32,
    pub border_id: i32,
-    #[serde(default = "default_as_true")]
-    #[serde(skip_serializing_if = "is_true")]
    pub apply_number_format: bool,
-    #[serde(default = "default_as_true")]
-    #[serde(skip_serializing_if = "is_true")]
    pub apply_border: bool,
-    #[serde(default = "default_as_true")]
-    #[serde(skip_serializing_if = "is_true")]
    pub apply_alignment: bool,
-    #[serde(default = "default_as_true")]
-    #[serde(skip_serializing_if = "is_true")]
    pub apply_protection: bool,
-    #[serde(default = "default_as_true")]
-    #[serde(skip_serializing_if = "is_true")]
    pub apply_font: bool,
-    #[serde(default = "default_as_true")]
-    #[serde(skip_serializing_if = "is_true")]
    pub apply_fill: bool,
 }

@@ -559,39 +544,24 @@ impl Default for CellStyleXfs {
    }
 }

-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone, Default)]
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone, Default)]
 pub struct CellXfs {
    pub xf_id: i32,
    pub num_fmt_id: i32,
    pub font_id: i32,
    pub fill_id: i32,
    pub border_id: i32,
-    #[serde(default = "default_as_false")]
-    #[serde(skip_serializing_if = "is_false")]
    pub apply_number_format: bool,
-    #[serde(default = "default_as_false")]
-    #[serde(skip_serializing_if = "is_false")]
    pub apply_border: bool,
-    #[serde(default = "default_as_false")]
-    #[serde(skip_serializing_if = "is_false")]
    pub apply_alignment: bool,
-    #[serde(default = "default_as_false")]
-    #[serde(skip_serializing_if = "is_false")]
    pub apply_protection: bool,
-    #[serde(default = "default_as_false")]
-    #[serde(skip_serializing_if = "is_false")]
    pub apply_font: bool,
-    #[serde(default = "default_as_false")]
-    #[serde(skip_serializing_if = "is_false")]
    pub apply_fill: bool,
-    #[serde(default = "default_as_false")]
-    #[serde(skip_serializing_if = "is_false")]
    pub quote_prefix: bool,
-    #[serde(skip_serializing_if = "is_default_alignment")]
    pub alignment: Option<Alignment>,
 }

-#[derive(Serialize, Deserialize, Encode, Decode, Debug, PartialEq, Eq, Clone)]
+#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
 pub struct CellStyles {
    pub name: String,
    pub xf_id: i32,
--- a/base/src/units.rs
+++ b/base/src/units.rs
@@ -7,17 +7,20 @@ use crate::{

 pub enum Units {
    Number {
+        #[allow(dead_code)]
        group_separator: bool,
        precision: i32,
        num_fmt: String,
    },
    Currency {
+        #[allow(dead_code)]
        group_separator: bool,
        precision: i32,
        num_fmt: String,
        currency: String,
    },
    Percentage {
+        #[allow(dead_code)]
        group_separator: bool,
        precision: i32,
        num_fmt: String,
@@ -86,12 +89,15 @@ fn get_units_from_format_string(num_fmt: &str) -> Option<Units> {

 impl Model {
    fn compute_cell_units(&self, cell_reference: &CellReferenceIndex) -> Option<Units> {
-        let style = &self.get_style_for_cell(
+        let cell_style_res = &self.get_style_for_cell(
            cell_reference.sheet,
            cell_reference.row,
            cell_reference.column,
        );
-        get_units_from_format_string(&style.num_fmt)
+        match cell_style_res {
+            Ok(style) => get_units_from_format_string(&style.num_fmt),
+            Err(_) => None,
+        }
    }

    pub(crate) fn compute_node_units(
--- a/base/src/user_model/common.rs
+++ b/base/src/user_model/common.rs
--- a/base/src/user_model/history.rs
+++ b/base/src/user_model/history.rs
@@ -0,0 +1,164 @@
+use std::collections::HashMap;
+
+use bitcode::{Decode, Encode};
+
+use crate::types::{Cell, Col, Row, Style};
+
+#[derive(Clone, Encode, Decode)]
+pub(crate) struct RowData {
+    pub(crate) row: Option<Row>,
+    pub(crate) data: HashMap<i32, Cell>,
+}
+
+#[derive(Clone, Encode, Decode)]
+pub(crate) struct ColumnData {
+    pub(crate) column: Option<Col>,
+    pub(crate) data: HashMap<i32, Cell>,
+}
+
+#[derive(Clone, Encode, Decode)]
+pub(crate) enum Diff {
+    // Cell diffs
+    SetCellValue {
+        sheet: u32,
+        row: i32,
+        column: i32,
+        new_value: String,
+        old_value: Box<Option<Cell>>,
+    },
+    CellClearContents {
+        sheet: u32,
+        row: i32,
+        column: i32,
+        old_value: Box<Option<Cell>>,
+    },
+    CellClearAll {
+        sheet: u32,
+        row: i32,
+        column: i32,
+        old_value: Box<Option<Cell>>,
+        old_style: Box<Style>,
+    },
+    SetCellStyle {
+        sheet: u32,
+        row: i32,
+        column: i32,
+        old_value: Box<Style>,
+        new_value: Box<Style>,
+    },
+    // Column and Row diffs
+    SetColumnWidth {
+        sheet: u32,
+        column: i32,
+        new_value: f64,
+        old_value: f64,
+    },
+    SetRowHeight {
+        sheet: u32,
+        row: i32,
+        new_value: f64,
+        old_value: f64,
+    },
+    InsertRow {
+        sheet: u32,
+        row: i32,
+    },
+    DeleteRow {
+        sheet: u32,
+        row: i32,
+        old_data: Box<RowData>,
+    },
+    InsertColumn {
+        sheet: u32,
+        column: i32,
+    },
+    DeleteColumn {
+        sheet: u32,
+        column: i32,
+        old_data: Box<ColumnData>,
+    },
+    SetFrozenRowsCount {
+        sheet: u32,
+        new_value: i32,
+        old_value: i32,
+    },
+    SetFrozenColumnsCount {
+        sheet: u32,
+        new_value: i32,
+        old_value: i32,
+    },
+    DeleteSheet {
+        sheet: u32,
+    },
+    NewSheet {
+        index: u32,
+        name: String,
+    },
+    RenameSheet {
+        index: u32,
+        old_value: String,
+        new_value: String,
+    },
+    SetSheetColor {
+        index: u32,
+        old_value: String,
+        new_value: String,
+    },
+    SetShowGridLines {
+        sheet: u32,
+        old_value: bool,
+        new_value: bool,
+    }, // FIXME: we are missing SetViewDiffs
+}
+
+pub(crate) type DiffList = Vec<Diff>;
+
+#[derive(Default)]
+pub(crate) struct History {
+    pub(crate) undo_stack: Vec<DiffList>,
+    pub(crate) redo_stack: Vec<DiffList>,
+}
+
+impl History {
+    pub fn push(&mut self, diff_list: DiffList) {
+        self.undo_stack.push(diff_list);
+        self.redo_stack = vec![];
+    }
+
+    pub fn undo(&mut self) -> Option<Vec<Diff>> {
+        match self.undo_stack.pop() {
+            Some(diff_list) => {
+                self.redo_stack.push(diff_list.clone());
+                Some(diff_list)
+            }
+            None => None,
+        }
+    }
+
+    pub fn redo(&mut self) -> Option<Vec<Diff>> {
+        match self.redo_stack.pop() {
+            Some(diff_list) => {
+                self.undo_stack.push(diff_list.clone());
+                Some(diff_list)
+            }
+            None => None,
+        }
+    }
+
+    pub fn clear(&mut self) {
+        self.redo_stack = vec![];
+        self.undo_stack = vec![];
+    }
+}
+
+#[derive(Clone, Encode, Decode)]
+pub enum DiffType {
+    Undo,
+    Redo,
+}
+
+#[derive(Clone, Encode, Decode)]
+pub struct QueueDiffs {
+    pub r#type: DiffType,
+    pub list: DiffList,
+}
--- a/base/src/user_model/mod.rs
+++ b/base/src/user_model/mod.rs
@@ -0,0 +1,13 @@
+#![deny(missing_docs)]
+
+mod common;
+mod history;
+mod ui;
+
+pub use common::UserModel;
+
+#[cfg(test)]
+pub use ui::SelectedView;
+
+pub use common::BorderArea;
+pub use common::ClipboardData;
--- a/base/src/user_model/ui.rs
+++ b/base/src/user_model/ui.rs
@@ -0,0 +1,687 @@
+#![deny(missing_docs)]
+
+use serde::{Deserialize, Serialize};
+
+use crate::expressions::utils::{is_valid_column_number, is_valid_row};
+
+use super::common::UserModel;
+
+#[derive(Serialize, Deserialize)]
+#[cfg_attr(test, derive(PartialEq, Debug))]
+pub struct SelectedView {
+    pub sheet: u32,
+    pub row: i32,
+    pub column: i32,
+    pub range: [i32; 4],
+    pub top_row: i32,
+    pub left_column: i32,
+}
+
+impl UserModel {
+    /// Returns the selected sheet index
+    pub fn get_selected_sheet(&self) -> u32 {
+        if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+            view.sheet
+        } else {
+            0
+        }
+    }
+
+    /// Returns the selected cell
+    pub fn get_selected_cell(&self) -> (u32, i32, i32) {
+        let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+            view.sheet
+        } else {
+            0
+        };
+        if let Ok(worksheet) = self.model.workbook.worksheet(sheet) {
+            if let Some(view) = worksheet.views.get(&self.model.view_id) {
+                return (sheet, view.row, view.column);
+            }
+        }
+        // return a safe default
+        (0, 1, 1)
+    }
+
+    /// Returns selected view
+    pub fn get_selected_view(&self) -> SelectedView {
+        let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+            view.sheet
+        } else {
+            0
+        };
+        if let Ok(worksheet) = self.model.workbook.worksheet(sheet) {
+            if let Some(view) = worksheet.views.get(&self.model.view_id) {
+                return SelectedView {
+                    sheet,
+                    row: view.row,
+                    column: view.column,
+                    range: view.range,
+                    top_row: view.top_row,
+                    left_column: view.left_column,
+                };
+            }
+        }
+        // return a safe default
+        SelectedView {
+            sheet: 0,
+            row: 1,
+            column: 1,
+            range: [1, 1, 1, 1],
+            top_row: 1,
+            left_column: 1,
+        }
+    }
+
+    /// Sets the the selected sheet
+    pub fn set_selected_sheet(&mut self, sheet: u32) -> Result<(), String> {
+        if self.model.workbook.worksheet(sheet).is_err() {
+            return Err(format!("Invalid worksheet index {}", sheet));
+        }
+        if let Some(view) = self.model.workbook.views.get_mut(&0) {
+            view.sheet = sheet;
+        }
+        Ok(())
+    }
+
+    /// Sets the selected cell for the current view. Note that this also sets the selected range
+    pub fn set_selected_cell(&mut self, row: i32, column: i32) -> Result<(), String> {
+        let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+            view.sheet
+        } else {
+            0
+        };
+        if !is_valid_column_number(column) {
+            return Err(format!("Invalid column: '{column}'"));
+        }
+        if !is_valid_row(row) {
+            return Err(format!("Invalid row: '{row}'"));
+        }
+        if self.model.workbook.worksheet(sheet).is_err() {
+            return Err(format!("Invalid worksheet index {}", sheet));
+        }
+        if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
+            if let Some(view) = worksheet.views.get_mut(&0) {
+                view.row = row;
+                view.column = column;
+                view.range = [row, column, row, column];
+            }
+        }
+        Ok(())
+    }
+
+    /// Sets the selected range. Note that the selected cell must be in one of the corners.
+    pub fn set_selected_range(
+        &mut self,
+        start_row: i32,
+        start_column: i32,
+        end_row: i32,
+        end_column: i32,
+    ) -> Result<(), String> {
+        let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+            view.sheet
+        } else {
+            0
+        };
+
+        if !is_valid_column_number(start_column) {
+            return Err(format!("Invalid column: '{start_column}'"));
+        }
+        if !is_valid_row(start_row) {
+            return Err(format!("Invalid row: '{start_row}'"));
+        }
+
+        if !is_valid_column_number(end_column) {
+            return Err(format!("Invalid column: '{end_column}'"));
+        }
+        if !is_valid_row(end_row) {
+            return Err(format!("Invalid row: '{end_row}'"));
+        }
+        if self.model.workbook.worksheet(sheet).is_err() {
+            return Err(format!("Invalid worksheet index {}", sheet));
+        }
+        if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
+            if let Some(view) = worksheet.views.get_mut(&0) {
+                let selected_row = view.row;
+                let selected_column = view.column;
+                // The selected cells must be on one of the corners of the selected range:
+                if selected_row != start_row && selected_row != end_row {
+                    return Err(format!(
+                        "The selected cells is not in one of the corners. Row: '{}' and row range '({}, {})'",
+                        selected_row, start_row, end_row
+                    ));
+                }
+                if selected_column != start_column && selected_column != end_column {
+                    return Err(format!(
+                        "The selected cells is not in one of the corners. Column '{}' and column range '({}, {})'",
+                        selected_column, start_column, end_column
+                    ));
+                }
+                view.range = [start_row, start_column, end_row, end_column];
+            }
+        }
+        Ok(())
+    }
+
+    /// The selected range is expanded with the keyboard
+    pub fn on_expand_selected_range(&mut self, key: &str) -> Result<(), String> {
+        let (sheet, window_width, window_height) =
+            if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+                (
+                    view.sheet,
+                    view.window_width as f64,
+                    view.window_height as f64,
+                )
+            } else {
+                return Ok(());
+            };
+        let (selected_row, selected_column, range, top_row, left_column) =
+            if let Ok(worksheet) = self.model.workbook.worksheet(sheet) {
+                if let Some(view) = worksheet.views.get(&self.model.view_id) {
+                    (
+                        view.row,
+                        view.column,
+                        view.range,
+                        view.top_row,
+                        view.left_column,
+                    )
+                } else {
+                    return Ok(());
+                }
+            } else {
+                return Ok(());
+            };
+        let [row_start, column_start, row_end, column_end] = range;
+
+        match key {
+            "ArrowRight" => {
+                if selected_column > column_start {
+                    let new_column = column_start + 1;
+                    if !(is_valid_column_number(new_column)) {
+                        return Ok(());
+                    }
+                    self.set_selected_range(row_start, new_column, row_end, column_end)?;
+                } else {
+                    let new_column = column_end + 1;
+                    if !is_valid_column_number(new_column) {
+                        return Ok(());
+                    }
+                    // if the column is not fully visible we 'scroll' right until it is
+                    let mut width = 0.0;
+                    let mut c = left_column;
+                    while c <= new_column {
+                        width += self.model.get_column_width(sheet, c)?;
+                        c += 1;
+                    }
+                    if width > window_width {
+                        self.set_top_left_visible_cell(top_row, left_column + 1)?;
+                    }
+                    self.set_selected_range(row_start, column_start, row_end, column_end + 1)?;
+                }
+            }
+            "ArrowLeft" => {
+                if selected_column < column_end {
+                    let new_column = column_end - 1;
+                    if !is_valid_column_number(new_column) {
+                        return Ok(());
+                    }
+                    if new_column < left_column {
+                        self.set_top_left_visible_cell(top_row, new_column)?;
+                    }
+                    self.set_selected_range(row_start, column_start, row_end, new_column)?;
+                } else {
+                    let new_column = column_start - 1;
+                    if !is_valid_column_number(new_column) {
+                        return Ok(());
+                    }
+                    if new_column < left_column {
+                        self.set_top_left_visible_cell(top_row, new_column)?;
+                    }
+                    self.set_selected_range(row_start, new_column, row_end, column_end)?;
+                }
+            }
+            "ArrowUp" => {
+                if selected_row < row_end {
+                    let new_row = row_end - 1;
+                    if !is_valid_row(new_row) {
+                        return Ok(());
+                    }
+                    self.set_selected_range(row_start, column_start, new_row, column_end)?;
+                } else {
+                    let new_row = row_start - 1;
+                    if !is_valid_row(new_row) {
+                        return Ok(());
+                    }
+                    if new_row < top_row {
+                        self.set_top_left_visible_cell(new_row, left_column)?;
+                    }
+                    self.set_selected_range(new_row, column_start, row_end, column_end)?;
+                }
+            }
+            "ArrowDown" => {
+                if selected_row > row_start {
+                    let new_row = row_start + 1;
+                    if !is_valid_row(new_row) {
+                        return Ok(());
+                    }
+                    self.set_selected_range(new_row, column_start, row_end, column_end)?;
+                } else {
+                    let new_row = row_end + 1;
+                    if !is_valid_row(new_row) {
+                        return Ok(());
+                    }
+                    let mut height = 0.0;
+                    let mut r = top_row;
+                    while r <= new_row + 1 {
+                        height += self.model.get_row_height(sheet, r)?;
+                        r += 1;
+                    }
+                    if height >= window_height {
+                        self.set_top_left_visible_cell(top_row + 1, left_column)?;
+                    }
+                    self.set_selected_range(row_start, column_start, new_row, column_end)?;
+                }
+            }
+            _ => {}
+        }
+
+        Ok(())
+    }
+
+    /// Sets the value of the first visible cell
+    pub fn set_top_left_visible_cell(
+        &mut self,
+        top_row: i32,
+        left_column: i32,
+    ) -> Result<(), String> {
+        let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+            view.sheet
+        } else {
+            0
+        };
+
+        if !is_valid_column_number(left_column) {
+            return Err(format!("Invalid column: '{left_column}'"));
+        }
+        if !is_valid_row(top_row) {
+            return Err(format!("Invalid row: '{top_row}'"));
+        }
+        if self.model.workbook.worksheet(sheet).is_err() {
+            return Err(format!("Invalid worksheet index {}", sheet));
+        }
+        if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
+            if let Some(view) = worksheet.views.get_mut(&0) {
+                view.top_row = top_row;
+                view.left_column = left_column;
+            }
+        }
+        Ok(())
+    }
+
+    /// Sets the width of the window
+    pub fn set_window_width(&mut self, window_width: f64) {
+        if let Some(view) = self.model.workbook.views.get_mut(&self.model.view_id) {
+            view.window_width = window_width as i64;
+        };
+    }
+
+    /// Gets the width of the window
+    pub fn get_window_width(&mut self) -> Result<i64, String> {
+        if let Some(view) = self.model.workbook.views.get_mut(&self.model.view_id) {
+            return Ok(view.window_width);
+        };
+        Err("View not found".to_string())
+    }
+
+    /// Sets the height of the window
+    pub fn set_window_height(&mut self, window_height: f64) {
+        if let Some(view) = self.model.workbook.views.get_mut(&self.model.view_id) {
+            view.window_height = window_height as i64;
+        };
+    }
+
+    /// Gets the height of the window
+    pub fn get_window_height(&mut self) -> Result<i64, String> {
+        if let Some(view) = self.model.workbook.views.get_mut(&self.model.view_id) {
+            return Ok(view.window_height);
+        };
+        Err("View not found".to_string())
+    }
+
+    /// User presses right arrow
+    pub fn on_arrow_right(&mut self) -> Result<(), String> {
+        let (sheet, window_width) =
+            if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+                (view.sheet, view.window_width)
+            } else {
+                return Err("View not found".to_string());
+            };
+        let worksheet = match self.model.workbook.worksheet(sheet) {
+            Ok(s) => s,
+            Err(_) => return Err("Worksheet not found".to_string()),
+        };
+        let view = match worksheet.views.get(&self.model.view_id) {
+            Some(s) => s,
+            None => return Err("View not found".to_string()),
+        };
+        let new_column = view.column + 1;
+        if !is_valid_column_number(new_column) {
+            return Ok(());
+        }
+        // if the column is not fully visible we 'scroll' right until it is
+        let mut width = 0.0;
+        let mut column = view.left_column;
+        while column <= new_column {
+            width += self.model.get_column_width(sheet, column)?;
+            column += 1;
+        }
+        if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
+            if let Some(view) = worksheet.views.get_mut(&self.model.view_id) {
+                view.column = new_column;
+                view.range = [view.row, new_column, view.row, new_column];
+                if width > window_width as f64 {
+                    view.left_column += 1;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// User presses left arrow
+    pub fn on_arrow_left(&mut self) -> Result<(), String> {
+        let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+            view.sheet
+        } else {
+            return Err("View not found".to_string());
+        };
+        let worksheet = match self.model.workbook.worksheet(sheet) {
+            Ok(s) => s,
+            Err(_) => return Err("Worksheet not found".to_string()),
+        };
+        let view = match worksheet.views.get(&self.model.view_id) {
+            Some(s) => s,
+            None => return Err("View not found".to_string()),
+        };
+        let new_column = view.column - 1;
+        if !is_valid_column_number(new_column) {
+            return Ok(());
+        }
+        // if the column is not fully visible we 'scroll' right until it is
+        if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
+            if let Some(view) = worksheet.views.get_mut(&self.model.view_id) {
+                view.column = new_column;
+                view.range = [view.row, new_column, view.row, new_column];
+                if new_column < view.left_column {
+                    view.left_column = new_column;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// User presses up arrow key
+    pub fn on_arrow_up(&mut self) -> Result<(), String> {
+        let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+            view.sheet
+        } else {
+            return Err("View not found".to_string());
+        };
+        let worksheet = match self.model.workbook.worksheet(sheet) {
+            Ok(s) => s,
+            Err(_) => return Err("Worksheet not found".to_string()),
+        };
+        let view = match worksheet.views.get(&self.model.view_id) {
+            Some(s) => s,
+            None => return Err("View not found".to_string()),
+        };
+        let new_row = view.row - 1;
+        if !is_valid_row(new_row) {
+            return Ok(());
+        }
+        // if the column is not fully visible we 'scroll' right until it is
+        if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
+            if let Some(view) = worksheet.views.get_mut(&self.model.view_id) {
+                view.row = new_row;
+                view.range = [new_row, view.column, new_row, view.column];
+                if new_row < view.top_row {
+                    view.top_row = new_row;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// User presses down arrow key
+    pub fn on_arrow_down(&mut self) -> Result<(), String> {
+        let (sheet, window_height) =
+            if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+                (view.sheet, view.window_height)
+            } else {
+                return Err("View not found".to_string());
+            };
+        let worksheet = match self.model.workbook.worksheet(sheet) {
+            Ok(s) => s,
+            Err(_) => return Err("Worksheet not found".to_string()),
+        };
+        let view = match worksheet.views.get(&self.model.view_id) {
+            Some(s) => s,
+            None => return Err("View not found".to_string()),
+        };
+        let new_row = view.row + 1;
+        if !is_valid_row(new_row) {
+            return Ok(());
+        }
+        // if the row is not fully visible we 'scroll' down until it is
+        let mut height = 0.0;
+        let mut row = view.top_row;
+        while row <= new_row + 1 {
+            height += self.model.get_row_height(sheet, row)?;
+            row += 1;
+        }
+        if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
+            if let Some(view) = worksheet.views.get_mut(&self.model.view_id) {
+                view.row = new_row;
+                view.range = [new_row, view.column, new_row, view.column];
+                if height > window_height as f64 {
+                    view.top_row += 1;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    // TODO: This function should be memoized
+    /// Returns the x-coordinate of the cell in the top left corner
+    pub fn get_scroll_x(&self) -> Result<f64, String> {
+        let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+            view.sheet
+        } else {
+            return Err("View not found".to_string());
+        };
+        let worksheet = match self.model.workbook.worksheet(sheet) {
+            Ok(s) => s,
+            Err(_) => return Err("Worksheet not found".to_string()),
+        };
+        let view = match worksheet.views.get(&self.model.view_id) {
+            Some(s) => s,
+            None => return Err("View not found".to_string()),
+        };
+        let mut scroll_x = 0.0;
+        for column in 1..view.left_column {
+            scroll_x += self.model.get_column_width(sheet, column)?;
+        }
+        Ok(scroll_x)
+    }
+
+    // TODO: This function should be memoized
+    /// Returns the y-coordinate of the cell in the top left corner
+    pub fn get_scroll_y(&self) -> Result<f64, String> {
+        let sheet = if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+            view.sheet
+        } else {
+            return Err("View not found".to_string());
+        };
+        let worksheet = match self.model.workbook.worksheet(sheet) {
+            Ok(s) => s,
+            Err(_) => return Err("Worksheet not found".to_string()),
+        };
+        let view = match worksheet.views.get(&self.model.view_id) {
+            Some(s) => s,
+            None => return Err("View not found".to_string()),
+        };
+        let mut scroll_y = 0.0;
+        for row in 1..view.top_row {
+            scroll_y += self.model.get_row_height(sheet, row)?;
+        }
+        Ok(scroll_y)
+    }
+
+    /// User presses page down.
+    /// The `top_row` is now the first row that is not fully visible
+    pub fn on_page_down(&mut self) -> Result<(), String> {
+        let (sheet, window_height) =
+            if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+                (view.sheet, view.window_height)
+            } else {
+                return Err("View not found".to_string());
+            };
+        let worksheet = match self.model.workbook.worksheet(sheet) {
+            Ok(s) => s,
+            Err(_) => return Err("Worksheet not found".to_string()),
+        };
+        let view = match worksheet.views.get(&self.model.view_id) {
+            Some(s) => s,
+            None => return Err("View not found".to_string()),
+        };
+        let mut last_row = view.top_row;
+        let mut height = self.model.get_row_height(sheet, last_row)?;
+        while height <= window_height as f64 {
+            last_row += 1;
+            height += self.model.get_row_height(sheet, last_row)?;
+        }
+        if !is_valid_row(last_row) {
+            return Ok(());
+        }
+        let row_delta = view.row - view.top_row;
+        if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
+            if let Some(view) = worksheet.views.get_mut(&self.model.view_id) {
+                view.top_row = last_row;
+                view.row = view.top_row + row_delta;
+                view.range = [view.row, view.column, view.row, view.column];
+            }
+        }
+        Ok(())
+    }
+
+    /// On page up. tis needs to be the inverse of page down
+    pub fn on_page_up(&mut self) -> Result<(), String> {
+        let (sheet, window_height) =
+            if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+                (view.sheet, view.window_height as f64)
+            } else {
+                return Err("View not found".to_string());
+            };
+        let worksheet = match self.model.workbook.worksheet(sheet) {
+            Ok(s) => s,
+            Err(_) => return Err("Worksheet not found".to_string()),
+        };
+        let view = match worksheet.views.get(&self.model.view_id) {
+            Some(s) => s,
+            None => return Err("View not found".to_string()),
+        };
+
+        let mut first_row = view.top_row;
+        let mut height = self.model.get_row_height(sheet, first_row)?;
+        while height <= window_height && first_row > 1 {
+            first_row -= 1;
+            height += self.model.get_row_height(sheet, first_row)?;
+        }
+
+        let row_delta = view.row - view.top_row;
+        if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
+            if let Some(view) = worksheet.views.get_mut(&self.model.view_id) {
+                view.top_row = first_row;
+                view.row = view.top_row + row_delta;
+                view.range = [view.row, view.column, view.row, view.column];
+            }
+        }
+        Ok(())
+    }
+
+    /// We extend the selection to cell (target_row, target_column)
+    pub fn on_area_selecting(&mut self, target_row: i32, target_column: i32) -> Result<(), String> {
+        let (sheet, window_width, window_height) =
+            if let Some(view) = self.model.workbook.views.get(&self.model.view_id) {
+                (
+                    view.sheet,
+                    view.window_width as f64,
+                    view.window_height as f64,
+                )
+            } else {
+                return Ok(());
+            };
+        let (selected_row, selected_column, range, top_row, left_column) =
+            if let Ok(worksheet) = self.model.workbook.worksheet(sheet) {
+                if let Some(view) = worksheet.views.get(&self.model.view_id) {
+                    (
+                        view.row,
+                        view.column,
+                        view.range,
+                        view.top_row,
+                        view.left_column,
+                    )
+                } else {
+                    return Ok(());
+                }
+            } else {
+                return Ok(());
+            };
+        let [row_start, column_start, _row_end, _column_end] = range;
+
+        let mut new_left_column = left_column;
+        if target_column >= selected_column {
+            let mut width = 0.0;
+            let mut column = left_column;
+            while column <= target_column {
+                width += self.model.get_column_width(sheet, column)?;
+                column += 1;
+            }
+
+            while width > window_width {
+                width -= self.model.get_column_width(sheet, new_left_column)?;
+                new_left_column += 1;
+            }
+        } else if target_column < new_left_column {
+            new_left_column = target_column;
+        }
+        let mut new_top_row = top_row;
+        if target_row >= selected_row {
+            let mut height = 0.0;
+            let mut row = top_row;
+            while row <= target_row {
+                height += self.model.get_row_height(sheet, row)?;
+                row += 1;
+            }
+            while height > window_height {
+                height -= self.model.get_row_height(sheet, new_top_row)?;
+                new_top_row += 1;
+            }
+        } else if target_row < new_top_row {
+            new_top_row = target_row;
+        }
+
+        if let Ok(worksheet) = self.model.workbook.worksheet_mut(sheet) {
+            if let Some(view) = worksheet.views.get_mut(&self.model.view_id) {
+                view.range = [row_start, column_start, target_row, target_column];
+                if new_top_row != top_row {
+                    view.top_row = new_top_row;
+                }
+                if new_left_column != left_column {
+                    view.left_column = new_left_column;
+                }
+            }
+        }
+
+        Ok(())
+    }
+}
--- a/base/src/worksheet.rs
+++ b/base/src/worksheet.rs
@@ -42,7 +42,17 @@ impl Worksheet {
        self.sheet_data.get_mut(&row)?.get_mut(&column)
    }

-    pub(crate) fn update_cell(&mut self, row: i32, column: i32, new_cell: Cell) {
+    pub(crate) fn update_cell(
+        &mut self,
+        row: i32,
+        column: i32,
+        new_cell: Cell,
+    ) -> Result<(), String> {
+        // validate row and column arg before updating cell of worksheet
+        if !is_valid_row(row) || !is_valid_column_number(column) {
+            return Err("Incorrect row or column".to_string());
+        }
+
        match self.sheet_data.get_mut(&row) {
            Some(column_data) => match column_data.get(&column) {
                Some(_cell) => {
@@ -58,6 +68,7 @@ impl Worksheet {
                self.sheet_data.insert(row, column_data);
            }
        }
+        Ok(())
    }

    // TODO [MVP]: Pass the cell style from the model
@@ -128,53 +139,94 @@ impl Worksheet {
        Ok(())
    }

-    pub fn set_cell_style(&mut self, row: i32, column: i32, style_index: i32) {
+    pub fn set_cell_style(
+        &mut self,
+        row: i32,
+        column: i32,
+        style_index: i32,
+    ) -> Result<(), String> {
        match self.cell_mut(row, column) {
            Some(cell) => {
                cell.set_style(style_index);
            }
            None => {
-                self.cell_clear_contents_with_style(row, column, style_index);
+                self.cell_clear_contents_with_style(row, column, style_index)?;
            }
        }
+        Ok(())

        // TODO: cleanup check if the old cell style is still in use
    }

-    pub fn set_cell_with_formula(&mut self, row: i32, column: i32, index: i32, style: i32) {
+    pub fn set_cell_with_formula(
+        &mut self,
+        row: i32,
+        column: i32,
+        index: i32,
+        style: i32,
+    ) -> Result<(), String> {
        let cell = Cell::new_formula(index, style);
-        self.update_cell(row, column, cell);
+        self.update_cell(row, column, cell)
    }

-    pub fn set_cell_with_number(&mut self, row: i32, column: i32, value: f64, style: i32) {
+    pub fn set_cell_with_number(
+        &mut self,
+        row: i32,
+        column: i32,
+        value: f64,
+        style: i32,
+    ) -> Result<(), String> {
        let cell = Cell::new_number(value, style);
-        self.update_cell(row, column, cell);
+        self.update_cell(row, column, cell)
    }

-    pub fn set_cell_with_string(&mut self, row: i32, column: i32, index: i32, style: i32) {
+    pub fn set_cell_with_string(
+        &mut self,
+        row: i32,
+        column: i32,
+        index: i32,
+        style: i32,
+    ) -> Result<(), String> {
        let cell = Cell::new_string(index, style);
-        self.update_cell(row, column, cell);
+        self.update_cell(row, column, cell)
    }

-    pub fn set_cell_with_boolean(&mut self, row: i32, column: i32, value: bool, style: i32) {
+    pub fn set_cell_with_boolean(
+        &mut self,
+        row: i32,
+        column: i32,
+        value: bool,
+        style: i32,
+    ) -> Result<(), String> {
        let cell = Cell::new_boolean(value, style);
-        self.update_cell(row, column, cell);
+        self.update_cell(row, column, cell)
    }

-    pub fn set_cell_with_error(&mut self, row: i32, column: i32, error: Error, style: i32) {
+    pub fn set_cell_with_error(
+        &mut self,
+        row: i32,
+        column: i32,
+        error: Error,
+        style: i32,
+    ) -> Result<(), String> {
        let cell = Cell::new_error(error, style);
-        self.update_cell(row, column, cell);
+        self.update_cell(row, column, cell)
    }

-    pub fn cell_clear_contents(&mut self, row: i32, column: i32) {
+    pub fn cell_clear_contents(&mut self, row: i32, column: i32) -> Result<(), String> {
        let s = self.get_style(row, column);
        let cell = Cell::EmptyCell { s };
-        self.update_cell(row, column, cell);
+        self.update_cell(row, column, cell)
    }

-    pub fn cell_clear_contents_with_style(&mut self, row: i32, column: i32, style: i32) {
+    pub fn cell_clear_contents_with_style(
+        &mut self,
+        row: i32,
+        column: i32,
+        style: i32,
+    ) -> Result<(), String> {
        let cell = Cell::EmptyCell { s: style };
-        self.update_cell(row, column, cell);
+        self.update_cell(row, column, cell)
    }

    pub fn set_frozen_rows(&mut self, frozen_rows: i32) -> Result<(), String> {
--- a/bindings/python/.gitignore
+++ b/bindings/python/.gitignore
@@ -0,0 +1,5 @@
+target/*
+venv/*
+sphinx-venv/*
+html/*
+tests/__pycache*
--- a/bindings/python/Cargo.lock
+++ b/bindings/python/Cargo.lock
@@ -0,0 +1,884 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "adler"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2969dcb958b36655471fc61f7e416fa76033bdd4bfed0678d8fee1e2d07a1f0"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "android-tzdata"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bumpalo"
+version = "3.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f30e7476521f6f8af1a1c4c0b8cc94f0bee37d91763d0ca2665f299b6cd8aec"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "bzip2"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bdb116a6ef3f6c3698828873ad02c3014b3c85cadb88496095628e3ef1e347f8"
+dependencies = [
+ "bzip2-sys",
+ "libc",
+]
+
+[[package]]
+name = "bzip2-sys"
+version = "0.1.11+1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "736a955f3fa7875102d57c82b8cac37ec45224a07fd32d58f9f7a186b6cd4cdc"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+]
+
+[[package]]
+name = "cc"
+version = "1.0.83"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "chrono"
+version = "0.4.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f2c685bad3eb3d45a01354cedb7d5faa66194d1d58ba6e267a8de788f79db38"
+dependencies = [
+ "android-tzdata",
+ "iana-time-zone",
+ "js-sys",
+ "num-traits",
+ "wasm-bindgen",
+ "windows-targets",
+]
+
+[[package]]
+name = "chrono-tz"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbc529705a6e0028189c83f0a5dd9fb214105116f7e3c0eeab7ff0369766b0d1"
+dependencies = [
+ "chrono",
+ "chrono-tz-build",
+ "phf",
+]
+
+[[package]]
+name = "chrono-tz-build"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9998fb9f7e9b2111641485bf8beb32f92945f97f92a3d061f744cfef335f751"
+dependencies = [
+ "parse-zoneinfo",
+ "phf",
+ "phf_codegen",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e496a50fda8aacccc86d7529e2c1e0892dbd0f898a6b5645b5561b89c3210efa"
+
+[[package]]
+name = "crc32fast"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "either"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07"
+
+[[package]]
+name = "flate2"
+version = "1.0.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46303f565772937ffe1d394a4fac6f411c6013172fadde9dcdb1e147a086940e"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fe9006bed769170c11f845cf00c7c1e9092aeb3f268e007c3e760ac68008070f"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+]
+
+[[package]]
+name = "iana-time-zone"
+version = "0.1.58"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8326b86b6cff230b97d0d312a6c40a60726df3332e721f72a1b035f451663b20"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "wasm-bindgen",
+ "windows-core",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "indoc"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa799dd5ed20a7e349f3b4639aa80d74549c81716d9ec4f994c9b5815598306"
+
+[[package]]
+name = "instant"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "ironcalc"
+version = "0.1.0"
+dependencies = [
+ "chrono",
+ "ironcalc_base",
+ "itertools",
+ "roxmltree",
+ "serde",
+ "serde_json",
+ "thiserror",
+ "zip",
+]
+
+[[package]]
+name = "ironcalc_base"
+version = "0.1.0"
+dependencies = [
+ "chrono",
+ "chrono-tz",
+ "js-sys",
+ "once_cell",
+ "rand",
+ "regex",
+ "ryu",
+ "serde",
+ "serde_json",
+ "serde_repr",
+]
+
+[[package]]
+name = "itertools"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af150ab688ff2122fcef229be89cb50dd66af9e01a4ff320cc137eecc9bacc38"
+
+[[package]]
+name = "js-sys"
+version = "0.3.65"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54c0c35952f67de54bb584e9fd912b3023117cbafc0a77d8f3dee1fb5f572fe8"
+dependencies = [
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.150"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "89d92a4743f9a61002fae18374ed11e7973f530cb3a3255fb354818118b2203c"
+
+[[package]]
+name = "lock_api"
+version = "0.4.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c168f8615b12bc01f9c17e2eb0cc07dcae1940121185446edc3744920e8ef45"
+dependencies = [
+ "autocfg",
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f"
+
+[[package]]
+name = "memchr"
+version = "2.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f665ee40bc4a3c5590afb1e9677db74a508659dfd71e126420da8274909a0167"
+
+[[package]]
+name = "memoffset"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a634b1c61a95585bd15607c6ab0c4e5b226e695ff2800ba0cdccddf208c406c"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "miniz_oxide"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7810e0be55b428ada41041c41f32c9f1a42817901b4ccf45fa3d4b6561e74c7"
+dependencies = [
+ "adler",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39e3200413f237f41ab11ad6d161bc7239c84dcb631773ccd7de3dfe4b5c267c"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d"
+
+[[package]]
+name = "parking_lot"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d17b78036a60663b797adeaee46f5c9dfebb86948d1255007a1d6be0271ff99"
+dependencies = [
+ "instant",
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60a2cfe6f0ad2bfc16aefa463b497d5c7a5ecd44a23efa72aa342d90177356dc"
+dependencies = [
+ "cfg-if",
+ "instant",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "winapi",
+]
+
+[[package]]
+name = "parse-zoneinfo"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c705f256449c60da65e11ff6626e0c16a0a0b96aaa348de61376b249bc340f41"
+dependencies = [
+ "regex",
+]
+
+[[package]]
+name = "phf"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ade2d8b8f33c7333b51bcf0428d37e217e9f32192ae4772156f65063b8ce03dc"
+dependencies = [
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_codegen"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8d39688d359e6b34654d328e262234662d16cc0f60ec8dcbe5e718709342a5a"
+dependencies = [
+ "phf_generator",
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_generator"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48e4cc64c2ad9ebe670cb8fd69dd50ae301650392e81c05f9bfcb2d5bdbc24b0"
+dependencies = [
+ "phf_shared",
+ "rand",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90fcb95eef784c2ac79119d1dd819e162b5da872ce6f3c3abe1e8ca1c082f72b"
+dependencies = [
+ "siphasher",
+]
+
+[[package]]
+name = "pkg-config"
+version = "0.3.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26072860ba924cbfa98ea39c8c19b4dd6a4a25423dbdf219c1eca91aa0cf6964"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "134c189feb4956b20f6f547d2cf727d4c0fe06722b20a0eec87ed445a97f92da"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.19.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e681a6cfdc4adcc93b4d3cf993749a4552018ee0a9b65fc0ccfad74352c72a38"
+dependencies = [
+ "cfg-if",
+ "indoc",
+ "libc",
+ "memoffset",
+ "parking_lot",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+ "unindent",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.19.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "076c73d0bc438f7a4ef6fdd0c3bb4732149136abd952b110ac93e4edb13a6ba5"
+dependencies = [
+ "once_cell",
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.19.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e53cee42e77ebe256066ba8aa77eff722b3bb91f3419177cf4cd0f304d3284d9"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.19.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfeb4c99597e136528c6dd7d5e3de5434d1ceaf487436a3f03b2d56b6fc9efd1"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.19.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "947dc12175c254889edc0c02e399476c2f652b4b9ebd123aa655c224de259536"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "pyroncalc"
+version = "0.1.0"
+dependencies = [
+ "ironcalc",
+ "pyo3",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "regex"
+version = "1.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "380b951a9c5e80ddfd6136919eef32310721aa4aacd4889a8d39124b026ab343"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f804c7828047e88b2d32e2d7fe5a105da8ee3264f01902f796c8e067dc2483f"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
+
+[[package]]
+name = "roxmltree"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dbf7d7b1ea646d380d0e8153158063a6da7efe30ddbf3184042848e3f8a6f671"
+dependencies = [
+ "xmlparser",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ad4cc8da4ef723ed60bced201181d83791ad433213d8c24efffda1eec85d741"
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "serde"
+version = "1.0.192"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bca2a08484b285dcb282d0f67b26cadc0df8b19f8c12502c13d966bf9482f001"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.192"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6c7207fbec9faa48073f3e3074cbe553af6ea512d7c21ba46e434e70ea9fbc1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.39",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.108"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d1c7e3eac408d115102c4c24ad393e0821bb3a5df4d506a80f85f7a742a526b"
+dependencies = [
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "serde_repr"
+version = "0.1.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3081f5ffbb02284dda55132aa26daecedd7372a42417bbbab6f14ab7d6bb9145"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.39",
+]
+
+[[package]]
+name = "siphasher"
+version = "0.3.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38b58827f4464d87d377d175e90bf58eb00fd8716ff0a62f80356b5e61555d0d"
+
+[[package]]
+name = "smallvec"
+version = "1.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4dccd0940a2dcdf68d092b8cbab7dc0ad8fa938bf95787e1b916b0e3d0e8e970"
+
+[[package]]
+name = "syn"
+version = "1.0.109"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.39"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23e78b90f2fcf45d3e842032ce32e3f2d1545ba6636271dcbf24fa306d87be7a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.12.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14c39fd04924ca3a864207c66fc2cd7d22d7c016007f9ce846cbb9326331930a"
+
+[[package]]
+name = "thiserror"
+version = "1.0.50"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9a7210f5c9a7156bb50aa36aed4c95afb51df0df00713949448cf9e97d382d2"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.50"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "266b2e40bc00e5a6c09c3584011e08b06f123c00362c92b975ba9843aaaa14b8"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.39",
+]
+
+[[package]]
+name = "time"
+version = "0.1.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b797afad3f312d1c66a56d11d0316f916356d11bd158fbc6ca6389ff6bf805a"
+dependencies = [
+ "libc",
+ "wasi 0.10.0+wasi-snapshot-preview1",
+ "winapi",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+
+[[package]]
+name = "unindent"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1766d682d402817b5ac4490b3c3002d91dfa0d22812f341609f97b08757359c"
+
+[[package]]
+name = "wasi"
+version = "0.10.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.88"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7daec296f25a1bae309c0cd5c29c4b260e510e6d813c286b19eaadf409d40fce"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.88"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e397f4664c0e4e428e8313a469aaa58310d302159845980fd23b0f22a847f217"
+dependencies = [
+ "bumpalo",
+ "log",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.39",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.88"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5961017b3b08ad5f3fe39f1e79877f8ee7c23c5e5fd5eb80de95abc41f1f16b2"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.88"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5353b8dab669f5e10f5bd76df26a9360c748f054f862ff5f3f8aae0c7fb3907"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.39",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.88"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d046c5d029ba91a1ed14da14dca44b68bf2f124cfbaf741c54151fdb3e0750b"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows-core"
+version = "0.51.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1f8cf84f35d2db49a46868f947758c7a1138116f7fac3bc844f43ade1292e64"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
+
+[[package]]
+name = "xmlparser"
+version = "0.13.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "66fee0b777b0f5ac1c69bb06d361268faafa61cd4682ae064a171c16c433e9e4"
+
+[[package]]
+name = "zip"
+version = "0.5.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93ab48844d61251bb3835145c521d88aa4031d7139e8485990f60ca911fa0815"
+dependencies = [
+ "byteorder",
+ "bzip2",
+ "crc32fast",
+ "flate2",
+ "thiserror",
+ "time",
+]
--- a/bindings/python/Cargo.toml
+++ b/bindings/python/Cargo.toml
@@ -0,0 +1,24 @@
+[package]
+name = "pyroncalc"
+version = "0.1.2"
+edition = "2021"
+
+
+[lib]
+name = "ironcalc"
+crate-type = ["cdylib"]
+
+
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+xlsx = { package= "ironcalc", path = "../../xlsx", version = "0.2.0" }
+pyo3 = { version = "0.22.3", features = ["extension-module"] }
+
+
+[features]
+extension-module = ["pyo3/extension-module"]
+default = ["extension-module"]
+
+[tool.maturin]
+features = ["pyo3/extension-module"]
--- a/bindings/python/LICENSE-Apache-2.0.md
+++ b/bindings/python/LICENSE-Apache-2.0.md
@@ -0,0 +1,191 @@
+                                Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2023 EqualTo GmbH, 2023 Nicolás Hatcher
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
--- a/bindings/python/LICENSE-MIT.md
+++ b/bindings/python/LICENSE-MIT.md
@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2023 EqualTo GmbH, 2023 Nicolás Hatcher
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/bindings/python/README.md
+++ b/bindings/python/README.md
@@ -0,0 +1,31 @@
+# IronCalc python bindings
+
+With IronCalc you can create, read and manipulate xlsx files.
+You can manage sheets, add, remove, delete rename.
+You can add cell values, retrieve them and most importantly you can evaluate spreadsheets.
+
+## Installation
+
+```bash
+pip install ironcalc
+```
+
+
+
+
+## Compile and test
+
+To compile this and test it:
+
+```bash
+$ python3 -m venv venv
+$ source venv/bin/activate
+$ pip install maturin
+$ maturin develop
+$ cd examples
+examples $ python example.py
+```
+
+From there if you use `python` you can `import ironcalc`. You can either create a new file, read it from a JSON string or import from Excel.
+
+Hopefully the API is straightforward.
--- a/bindings/python/docs/conf.py
+++ b/bindings/python/docs/conf.py
@@ -0,0 +1,14 @@
+
+project = 'IronCalc'
+author = 'Nicolás Hatcher'
+
+release = '0.1'
+version = '0.1.2'
+
+extensions = ['sphinx.ext.autodoc', 'sphinx.ext.napoleon']
+
+templates_path = ['_templates']
+
+exclude_patterns = []
+
+html_theme = 'alabaster'
--- a/bindings/python/docs/examples/simple.py
+++ b/bindings/python/docs/examples/simple.py
@@ -0,0 +1,8 @@
+import ironcalc as ic
+
+model = ic.create("model", "en", "UTC")
+
+model.set_user_input(0, 1, 1, "=21*2")
+model.evaluate()
+
+assert model.get_formatted_cell_value(0, 1, 1), 42
--- a/bindings/python/docs/index.rst
+++ b/bindings/python/docs/index.rst
@@ -0,0 +1,13 @@
+IronCalc: The democratization of spreadsheets
+=============================================
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Contents:
+
+IronCalc is a spreadsheet engine that allows you to create, modify and safe spreadsheets.
+
+A simple example that creates a model, sets a formula, evaluates it and gets the result back:
+
+.. literalinclude:: examples/simple.py
+   :language: python
--- a/bindings/python/pyproject.toml
+++ b/bindings/python/pyproject.toml
@@ -0,0 +1,36 @@
+[project]
+name = "ironcalc"
+version = "0.1.2"
+description = "Create, edit and evaluate Excel spreadsheets"
+requires-python = ">=3.10"
+keywords = [
+  "xlsx",
+  "spreadsheet",
+]
+classifiers = [
+  "License :: OSI Approved :: MIT License",
+  "License :: OSI Approved :: Apache Software License",
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Topic :: Software Development :: Libraries",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+  "Office/Business :: Financial :: Spreadsheet",
+]
+authors = [
+  { name = "Nicolás Hatcher", email = "nicolas@theuniverse.today" },
+]
+
+[project.urls]
+Homepage = "https://www.ironcalc.com/"
+Source = "https://github.com/ironcalc/ironcalc"
+Tracker = "https://github.com/ironcalc/ironcalc/issues"
+
+[build-system]
+requires = ["maturin>=1.0,<2.0"]
+build-backend = "maturin"
+
+
+[tool.maturin]
+features = ["pyo3/extension-module"]
--- a/bindings/python/run_examples.sh
+++ b/bindings/python/run_examples.sh
@@ -0,0 +1,29 @@
+#!/bin/bash
+
+# Define the directory containing the Python files
+EXAMPLES_DIR="docs/examples"
+
+# Check if the directory exists
+if [ ! -d "$EXAMPLES_DIR" ]; then
+  echo "Directory $EXAMPLES_DIR does not exist."
+  exit 1
+fi
+
+# Iterate over all Python files in the examples directory
+for file in "$EXAMPLES_DIR"/*.py; do
+  # Check if there are any Python files
+  if [ -f "$file" ]; then
+    echo "Running $file..."
+    python "$file"
+    
+    # Check if the script ran successfully
+    if [ $? -ne 0 ]; then
+      echo "Error running $file"
+    else
+      echo "$file ran successfully"
+    fi
+  else
+    echo "No Python files found in $EXAMPLES_DIR"
+    exit 1
+  fi
+done
--- a/bindings/python/run_tests.sh
+++ b/bindings/python/run_tests.sh
@@ -0,0 +1,9 @@
+#!/bin/bash
+python -m venv venv
+source venv/bin/activate
+# not sure why this is needed
+pip install patchelf
+pip install maturin
+pip install pytest
+maturin develop
+pytest tests/
--- a/bindings/python/src/lib.rs
+++ b/bindings/python/src/lib.rs
@@ -0,0 +1,259 @@
+use pyo3::exceptions::PyException;
+use pyo3::{create_exception, prelude::*, wrap_pyfunction};
+
+use types::{PySheetProperty, PyStyle};
+use xlsx::base::types::Style;
+use xlsx::base::Model;
+
+use xlsx::export::{save_to_icalc, save_to_xlsx};
+use xlsx::import;
+
+mod types;
+
+create_exception!(_ironcalc, WorkbookError, PyException);
+
+/// This is a model implementing the 'raw' API
+#[pyclass]
+pub struct PyModel {
+    model: Model,
+}
+
+#[pymethods]
+impl PyModel {
+    /// Saves the model to an xlsx file
+    pub fn save_to_xlsx(&self, file: &str) -> PyResult<()> {
+        save_to_xlsx(&self.model, file).map_err(|e| WorkbookError::new_err(e.to_string()))
+    }
+
+    /// Saves the model to file in the internal binary ic format
+    pub fn save_to_icalc(&self, file: &str) -> PyResult<()> {
+        save_to_icalc(&self.model, file).map_err(|e| WorkbookError::new_err(e.to_string()))
+    }
+
+    /// Evaluates the workbook
+    pub fn evaluate(&mut self) {
+        self.model.evaluate()
+    }
+
+    // Set values
+
+    /// Set an input
+    pub fn set_user_input(
+        &mut self,
+        sheet: u32,
+        row: i32,
+        column: i32,
+        value: &str,
+    ) -> PyResult<()> {
+        self.model
+            .set_user_input(sheet, row, column, value.to_string())
+            .map_err(|e| WorkbookError::new_err(e.to_string()))
+    }
+
+    pub fn clear_cell_contents(&mut self, sheet: u32, row: i32, column: i32) -> PyResult<()> {
+        self.model
+            .cell_clear_contents(sheet, row, column)
+            .map_err(|e| WorkbookError::new_err(e.to_string()))
+    }
+
+    // Get values
+
+    /// Get formatted value
+    pub fn get_formatted_cell_value(&self, sheet: u32, row: i32, column: i32) -> PyResult<String> {
+        self.model
+            .get_formatted_cell_value(sheet, row, column)
+            .map_err(|e| WorkbookError::new_err(e.to_string()))
+    }
+
+    // Set styles
+    pub fn set_cell_style(
+        &mut self,
+        sheet: u32,
+        row: i32,
+        column: i32,
+        py_style: &PyStyle,
+    ) -> PyResult<()> {
+        let style: Style = py_style.into();
+        self.model
+            .set_cell_style(sheet, row, column, &style)
+            .map_err(|e| WorkbookError::new_err(e.to_string()))
+    }
+
+    // Get styles
+    pub fn get_cell_style(&self, sheet: u32, row: i32, column: i32) -> PyResult<PyStyle> {
+        let style = self
+            .model
+            .get_style_for_cell(sheet, row, column)
+            .map_err(|e| WorkbookError::new_err(e.to_string()))?;
+        Ok(style.into())
+    }
+
+    // column widths, row heights
+    // insert/delete rows/columns
+
+    pub fn insert_rows(&mut self, sheet: u32, row: i32, row_count: i32) -> PyResult<()> {
+        self.model
+            .insert_rows(sheet, row, row_count)
+            .map_err(|e| WorkbookError::new_err(e.to_string()))
+    }
+
+    pub fn insert_columns(&mut self, sheet: u32, column: i32, column_count: i32) -> PyResult<()> {
+        self.model
+            .insert_columns(sheet, column, column_count)
+            .map_err(|e| WorkbookError::new_err(e.to_string()))
+    }
+
+    pub fn delete_rows(&mut self, sheet: u32, row: i32, row_count: i32) -> PyResult<()> {
+        self.model
+            .delete_rows(sheet, row, row_count)
+            .map_err(|e| WorkbookError::new_err(e.to_string()))
+    }
+
+    pub fn delete_columns(&mut self, sheet: u32, column: i32, column_count: i32) -> PyResult<()> {
+        self.model
+            .delete_columns(sheet, column, column_count)
+            .map_err(|e| WorkbookError::new_err(e.to_string()))
+    }
+
+    pub fn get_column_width(&self, sheet: u32, column: i32) -> PyResult<f64> {
+        self.model
+            .get_column_width(sheet, column)
+            .map_err(|e| WorkbookError::new_err(e.to_string()))
+    }
+
+    pub fn get_row_height(&self, sheet: u32, row: i32) -> PyResult<f64> {
+        self.model
+            .get_row_height(sheet, row)
+            .map_err(|e| WorkbookError::new_err(e.to_string()))
+    }
+
+    pub fn set_column_width(&mut self, sheet: u32, column: i32, width: f64) -> PyResult<()> {
+        self.model
+            .set_column_width(sheet, column, width)
+            .map_err(|e| WorkbookError::new_err(e.to_string()))
+    }
+
+    pub fn set_row_height(&mut self, sheet: u32, row: i32, height: f64) -> PyResult<()> {
+        self.model
+            .set_row_height(sheet, row, height)
+            .map_err(|e| WorkbookError::new_err(e.to_string()))
+    }
+
+    // frozen rows/columns
+
+    pub fn get_frozen_columns_count(&self, sheet: u32) -> PyResult<i32> {
+        self.model
+            .get_frozen_columns_count(sheet)
+            .map_err(|e| WorkbookError::new_err(e.to_string()))
+    }
+
+    pub fn get_frozen_rows_count(&self, sheet: u32) -> PyResult<i32> {
+        self.model
+            .get_frozen_rows_count(sheet)
+            .map_err(|e| WorkbookError::new_err(e.to_string()))
+    }
+
+    pub fn set_frozen_columns_count(&mut self, sheet: u32, column_count: i32) -> PyResult<()> {
+        self.model
+            .set_frozen_columns(sheet, column_count)
+            .map_err(|e| WorkbookError::new_err(e.to_string()))
+    }
+
+    pub fn set_frozen_rows_count(&mut self, sheet: u32, row_count: i32) -> PyResult<()> {
+        self.model
+            .set_frozen_rows(sheet, row_count)
+            .map_err(|e| WorkbookError::new_err(e.to_string()))
+    }
+
+    // Manipulate sheets (add/remove/rename/change color)
+    pub fn get_worksheets_properties(&self) -> PyResult<Vec<PySheetProperty>> {
+        Ok(self
+            .model
+            .get_worksheets_properties()
+            .into_iter()
+            .map(|s| PySheetProperty {
+                name: s.name,
+                state: s.state,
+                sheet_id: s.sheet_id,
+                color: s.color,
+            })
+            .collect())
+    }
+
+    pub fn set_sheet_color(&mut self, sheet: u32, color: &str) -> PyResult<()> {
+        self.model
+            .set_sheet_color(sheet, color)
+            .map_err(|e| WorkbookError::new_err(e.to_string()))
+    }
+
+    pub fn add_sheet(&mut self, sheet_name: &str) -> PyResult<()> {
+        self.model
+            .add_sheet(sheet_name)
+            .map_err(|e| WorkbookError::new_err(e.to_string()))
+    }
+
+    pub fn new_sheet(&mut self) {
+        self.model.new_sheet();
+    }
+
+    pub fn delete_sheet(&mut self, sheet: u32) -> PyResult<()> {
+        self.model
+            .delete_sheet(sheet)
+            .map_err(|e| WorkbookError::new_err(e.to_string()))
+    }
+
+    pub fn rename_sheet(&mut self, sheet: u32, new_name: &str) -> PyResult<()> {
+        self.model
+            .rename_sheet_by_index(sheet, new_name)
+            .map_err(|e| WorkbookError::new_err(e.to_string()))
+    }
+
+    pub fn test_panic(&self) -> PyResult<()> {
+        panic!("This function panics for testing panic handling");
+    }
+}
+
+/// Create methods
+
+/// Loads a function from an xlsx file
+#[pyfunction]
+pub fn load_from_xlsx(file_path: &str, locale: &str, tz: &str) -> PyResult<PyModel> {
+    let model = import::load_from_xlsx(file_path, locale, tz)
+        .map_err(|e| WorkbookError::new_err(e.to_string()))?;
+    Ok(PyModel { model })
+}
+
+/// Loads a function from icalc binary representation
+#[pyfunction]
+pub fn load_from_icalc(file_name: &str) -> PyResult<PyModel> {
+    let model =
+        import::load_from_icalc(file_name).map_err(|e| WorkbookError::new_err(e.to_string()))?;
+    Ok(PyModel { model })
+}
+
+/// Creates an empty model
+#[pyfunction]
+pub fn create(name: &str, locale: &str, tz: &str) -> PyResult<PyModel> {
+    let model =
+        Model::new_empty(name, locale, tz).map_err(|e| WorkbookError::new_err(e.to_string()))?;
+    Ok(PyModel { model })
+}
+
+#[pyfunction]
+pub fn test_panic() {
+    panic!("This function panics for testing panic handling");
+}
+
+#[pymodule]
+fn ironcalc(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    // Add the package version to the module
+    m.add("__version__", env!("CARGO_PKG_VERSION"))?;
+
+    // Add the functions to the module using the `?` operator
+    m.add_function(wrap_pyfunction!(create, m)?)?;
+    m.add_function(wrap_pyfunction!(load_from_xlsx, m)?)?;
+    m.add_function(wrap_pyfunction!(load_from_icalc, m)?)?;
+    m.add_function(wrap_pyfunction!(test_panic, m)?)?;
+
+    Ok(())
+}
--- a/bindings/python/src/types.rs
+++ b/bindings/python/src/types.rs
@@ -0,0 +1,428 @@
+use pyo3::prelude::*;
+use xlsx::base::types::{
+    Alignment, Border, BorderItem, BorderStyle, Fill, Font, FontScheme, HorizontalAlignment, Style,
+    VerticalAlignment,
+};
+
+#[derive(Clone)]
+#[pyclass]
+pub struct PySheetProperty {
+    #[pyo3(get)]
+    pub name: String,
+    #[pyo3(get)]
+    pub state: String,
+    #[pyo3(get)]
+    pub sheet_id: u32,
+    #[pyo3(get)]
+    pub color: Option<String>,
+}
+
+#[pyclass]
+#[derive(Clone)]
+pub struct Cell {
+    #[pyo3(get, set)]
+    pub row: i32,
+    #[pyo3(get, set)]
+    pub column: i32,
+}
+
+#[pyclass(eq, eq_int)]
+#[derive(PartialEq, Clone)]
+pub enum PyHorizontalAlignment {
+    Center,
+    CenterContinuous,
+    Distributed,
+    Fill,
+    General,
+    Justify,
+    Left,
+    Right,
+}
+
+#[pyclass(eq, eq_int)]
+#[derive(PartialEq, Clone)]
+pub enum PyVerticalAlignment {
+    Bottom,
+    Center,
+    Distributed,
+    Justify,
+    Top,
+}
+
+#[pyclass]
+#[derive(Clone)]
+pub struct PyAlignment {
+    #[pyo3(get)]
+    pub horizontal: PyHorizontalAlignment,
+    #[pyo3(get)]
+    pub vertical: PyVerticalAlignment,
+    #[pyo3(get)]
+    pub wrap_text: bool,
+}
+
+#[pyclass]
+#[derive(Clone)]
+pub struct PyStyle {
+    #[pyo3(get)]
+    pub alignment: Option<PyAlignment>,
+    #[pyo3(get)]
+    pub num_fmt: String,
+    #[pyo3(get)]
+    pub fill: PyFill,
+    #[pyo3(get)]
+    pub font: PyFont,
+    #[pyo3(get)]
+    pub border: PyBorder,
+    #[pyo3(get)]
+    pub quote_prefix: bool,
+}
+
+#[pyclass(eq, eq_int)]
+#[derive(PartialEq, Clone)]
+pub enum PyBorderStyle {
+    Thin,
+    Medium,
+    Thick,
+    Double,
+    Dotted,
+    SlantDashDot,
+    MediumDashed,
+    MediumDashDotDot,
+    MediumDashDot,
+}
+
+#[pyclass]
+#[derive(Clone)]
+pub struct PyBorderItem {
+    #[pyo3(get)]
+    pub style: PyBorderStyle,
+    #[pyo3(get)]
+    pub color: Option<String>,
+}
+
+#[pyclass]
+#[derive(Clone)]
+pub struct PyBorder {
+    #[pyo3(get)]
+    pub diagonal_up: bool,
+    #[pyo3(get)]
+    pub diagonal_down: bool,
+    #[pyo3(get)]
+    pub left: Option<PyBorderItem>,
+    #[pyo3(get)]
+    pub right: Option<PyBorderItem>,
+    #[pyo3(get)]
+    pub top: Option<PyBorderItem>,
+    #[pyo3(get)]
+    pub bottom: Option<PyBorderItem>,
+    #[pyo3(get)]
+    pub diagonal: Option<PyBorderItem>,
+}
+
+#[pyclass(eq, eq_int)]
+#[derive(PartialEq, Clone)]
+pub enum PyFontScheme {
+    Minor,
+    Major,
+    None,
+}
+
+#[pyclass]
+#[derive(Clone)]
+pub struct PyFont {
+    #[pyo3(get)]
+    pub strike: bool,
+    #[pyo3(get)]
+    pub u: bool,
+    #[pyo3(get)]
+    pub b: bool,
+    #[pyo3(get)]
+    pub i: bool,
+    #[pyo3(get)]
+    pub sz: i32,
+    #[pyo3(get)]
+    pub color: Option<String>,
+    #[pyo3(get)]
+    pub name: String,
+    #[pyo3(get)]
+    pub family: i32,
+    #[pyo3(get)]
+    pub scheme: PyFontScheme,
+}
+
+#[pyclass]
+#[derive(Clone)]
+pub struct PyFill {
+    #[pyo3(get)]
+    pub pattern_type: String,
+    #[pyo3(get)]
+    pub fg_color: Option<String>,
+    #[pyo3(get)]
+    pub bg_color: Option<String>,
+}
+
+// Conversions from references to Py* types to non-Py types
+
+// Enums
+
+impl From<PyHorizontalAlignment> for HorizontalAlignment {
+    fn from(py_align: PyHorizontalAlignment) -> Self {
+        match py_align {
+            PyHorizontalAlignment::Center => HorizontalAlignment::Center,
+            PyHorizontalAlignment::CenterContinuous => HorizontalAlignment::CenterContinuous,
+            PyHorizontalAlignment::Distributed => HorizontalAlignment::Distributed,
+            PyHorizontalAlignment::Fill => HorizontalAlignment::Fill,
+            PyHorizontalAlignment::General => HorizontalAlignment::General,
+            PyHorizontalAlignment::Justify => HorizontalAlignment::Justify,
+            PyHorizontalAlignment::Left => HorizontalAlignment::Left,
+            PyHorizontalAlignment::Right => HorizontalAlignment::Right,
+        }
+    }
+}
+
+impl From<PyVerticalAlignment> for VerticalAlignment {
+    fn from(py_align: PyVerticalAlignment) -> Self {
+        match py_align {
+            PyVerticalAlignment::Bottom => VerticalAlignment::Bottom,
+            PyVerticalAlignment::Center => VerticalAlignment::Center,
+            PyVerticalAlignment::Distributed => VerticalAlignment::Distributed,
+            PyVerticalAlignment::Justify => VerticalAlignment::Justify,
+            PyVerticalAlignment::Top => VerticalAlignment::Top,
+        }
+    }
+}
+
+impl From<PyFontScheme> for FontScheme {
+    fn from(py_scheme: PyFontScheme) -> Self {
+        match py_scheme {
+            PyFontScheme::Minor => FontScheme::Minor,
+            PyFontScheme::Major => FontScheme::Major,
+            PyFontScheme::None => FontScheme::None,
+        }
+    }
+}
+
+impl From<&PyBorderStyle> for BorderStyle {
+    fn from(py_style: &PyBorderStyle) -> Self {
+        match *py_style {
+            PyBorderStyle::Thin => BorderStyle::Thin,
+            PyBorderStyle::Medium => BorderStyle::Medium,
+            PyBorderStyle::Thick => BorderStyle::Thick,
+            PyBorderStyle::Double => BorderStyle::Double,
+            PyBorderStyle::Dotted => BorderStyle::Dotted,
+            PyBorderStyle::SlantDashDot => BorderStyle::SlantDashDot,
+            PyBorderStyle::MediumDashed => BorderStyle::MediumDashed,
+            PyBorderStyle::MediumDashDotDot => BorderStyle::MediumDashDotDot,
+            PyBorderStyle::MediumDashDot => BorderStyle::MediumDashDot,
+        }
+    }
+}
+
+// Structs
+
+impl From<&PyFill> for Fill {
+    fn from(py_fill: &PyFill) -> Self {
+        Fill {
+            pattern_type: py_fill.pattern_type.clone(),
+            fg_color: py_fill.fg_color.clone(),
+            bg_color: py_fill.bg_color.clone(),
+        }
+    }
+}
+
+impl From<&PyFont> for Font {
+    fn from(py_font: &PyFont) -> Self {
+        Font {
+            strike: py_font.strike,
+            u: py_font.u,
+            b: py_font.b,
+            i: py_font.i,
+            sz: py_font.sz,
+            color: py_font.color.clone(),
+            name: py_font.name.clone(),
+            family: py_font.family,
+            scheme: py_font.scheme.clone().into(),
+        }
+    }
+}
+
+impl From<&PyBorderItem> for BorderItem {
+    fn from(py_item: &PyBorderItem) -> Self {
+        BorderItem {
+            style: (&py_item.style).into(),
+            color: py_item.color.clone(),
+        }
+    }
+}
+
+impl From<&PyBorder> for Border {
+    fn from(py_border: &PyBorder) -> Self {
+        Border {
+            diagonal_up: py_border.diagonal_up,
+            diagonal_down: py_border.diagonal_down,
+            left: py_border.left.as_ref().map(|item| item.into()),
+            right: py_border.right.as_ref().map(|item| item.into()),
+            top: py_border.top.as_ref().map(|item| item.into()),
+            bottom: py_border.bottom.as_ref().map(|item| item.into()),
+            diagonal: py_border.diagonal.as_ref().map(|item| item.into()),
+        }
+    }
+}
+
+impl From<&PyAlignment> for Alignment {
+    fn from(py_align: &PyAlignment) -> Self {
+        Alignment {
+            horizontal: py_align.horizontal.clone().into(),
+            vertical: py_align.vertical.clone().into(),
+            wrap_text: py_align.wrap_text,
+        }
+    }
+}
+
+impl From<&PyStyle> for Style {
+    fn from(py_style: &PyStyle) -> Self {
+        Style {
+            alignment: py_style.alignment.as_ref().map(|a| a.into()),
+            num_fmt: py_style.num_fmt.clone(),
+            fill: (&py_style.fill).into(),
+            font: (&py_style.font).into(),
+            border: (&py_style.border).into(),
+            quote_prefix: py_style.quote_prefix,
+        }
+    }
+}
+
+// From non-Py to Py
+impl From<Fill> for PyFill {
+    fn from(fill: Fill) -> Self {
+        PyFill {
+            pattern_type: fill.pattern_type,
+            fg_color: fill.fg_color,
+            bg_color: fill.bg_color,
+        }
+    }
+}
+
+// From non-Py to Py
+impl From<HorizontalAlignment> for PyHorizontalAlignment {
+    fn from(align: HorizontalAlignment) -> Self {
+        match align {
+            HorizontalAlignment::Center => PyHorizontalAlignment::Center,
+            HorizontalAlignment::CenterContinuous => PyHorizontalAlignment::CenterContinuous,
+            HorizontalAlignment::Distributed => PyHorizontalAlignment::Distributed,
+            HorizontalAlignment::Fill => PyHorizontalAlignment::Fill,
+            HorizontalAlignment::General => PyHorizontalAlignment::General,
+            HorizontalAlignment::Justify => PyHorizontalAlignment::Justify,
+            HorizontalAlignment::Left => PyHorizontalAlignment::Left,
+            HorizontalAlignment::Right => PyHorizontalAlignment::Right,
+        }
+    }
+}
+
+// From non-Py to Py
+impl From<VerticalAlignment> for PyVerticalAlignment {
+    fn from(align: VerticalAlignment) -> Self {
+        match align {
+            VerticalAlignment::Bottom => PyVerticalAlignment::Bottom,
+            VerticalAlignment::Center => PyVerticalAlignment::Center,
+            VerticalAlignment::Distributed => PyVerticalAlignment::Distributed,
+            VerticalAlignment::Justify => PyVerticalAlignment::Justify,
+            VerticalAlignment::Top => PyVerticalAlignment::Top,
+        }
+    }
+}
+
+// From non-Py to Py
+impl From<FontScheme> for PyFontScheme {
+    fn from(scheme: FontScheme) -> Self {
+        match scheme {
+            FontScheme::Minor => PyFontScheme::Minor,
+            FontScheme::Major => PyFontScheme::Major,
+            FontScheme::None => PyFontScheme::None,
+        }
+    }
+}
+
+// From non-Py to Py
+impl From<BorderStyle> for PyBorderStyle {
+    fn from(style: BorderStyle) -> Self {
+        match style {
+            BorderStyle::Thin => PyBorderStyle::Thin,
+            BorderStyle::Medium => PyBorderStyle::Medium,
+            BorderStyle::Thick => PyBorderStyle::Thick,
+            BorderStyle::Double => PyBorderStyle::Double,
+            BorderStyle::Dotted => PyBorderStyle::Dotted,
+            BorderStyle::SlantDashDot => PyBorderStyle::SlantDashDot,
+            BorderStyle::MediumDashed => PyBorderStyle::MediumDashed,
+            BorderStyle::MediumDashDotDot => PyBorderStyle::MediumDashDotDot,
+            BorderStyle::MediumDashDot => PyBorderStyle::MediumDashDot,
+        }
+    }
+}
+
+// From non-Py to Py
+impl From<Font> for PyFont {
+    fn from(font: Font) -> Self {
+        PyFont {
+            strike: font.strike,
+            u: font.u,
+            b: font.b,
+            i: font.i,
+            sz: font.sz,
+            color: font.color,
+            name: font.name,
+            family: font.family,
+            scheme: font.scheme.into(),
+        }
+    }
+}
+
+// From non-Py to Py
+impl From<BorderItem> for PyBorderItem {
+    fn from(item: BorderItem) -> Self {
+        PyBorderItem {
+            style: item.style.into(),
+            color: item.color,
+        }
+    }
+}
+
+// From non-Py to Py
+impl From<Border> for PyBorder {
+    fn from(border: Border) -> Self {
+        PyBorder {
+            diagonal_up: border.diagonal_up,
+            diagonal_down: border.diagonal_down,
+            left: border.left.map(|item| item.into()),
+            right: border.right.map(|item| item.into()),
+            top: border.top.map(|item| item.into()),
+            bottom: border.bottom.map(|item| item.into()),
+            diagonal: border.diagonal.map(|item| item.into()),
+        }
+    }
+}
+
+// From non-Py to Py
+impl From<Alignment> for PyAlignment {
+    fn from(align: Alignment) -> Self {
+        PyAlignment {
+            horizontal: align.horizontal.into(),
+            vertical: align.vertical.into(),
+            wrap_text: align.wrap_text,
+        }
+    }
+}
+
+// From non-Py to Py
+impl From<Style> for PyStyle {
+    fn from(style: Style) -> Self {
+        PyStyle {
+            alignment: style.alignment.map(|a| a.into()),
+            num_fmt: style.num_fmt,
+            fill: style.fill.into(),
+            font: style.font.into(),
+            border: style.border.into(),
+            quote_prefix: style.quote_prefix,
+        }
+    }
+}
--- a/bindings/python/tests/test_create.py
+++ b/bindings/python/tests/test_create.py
@@ -0,0 +1,8 @@
+import ironcalc as ic
+
+def test_simple():
+    model = ic.create("model", "en", "UTC")
+    model.set_user_input(0, 1, 1, "=1+2")
+    model.evaluate()
+
+    assert model.get_formatted_cell_value(0, 1, 1) == "3"
--- a/bindings/wasm/Cargo.toml
+++ b/bindings/wasm/Cargo.toml
@@ -14,7 +14,7 @@ crate-type = ["cdylib"]
 # Uses `../ironcalc/base` when used locally, and uses
 # the inicated version from crates.io when published.
 # https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html#multiple-locations
-ironcalc_base = { path = "../../base", version = "0.1" }
+ironcalc_base = { path = "../../base", version = "0.2" }
 serde = { version = "1.0", features = ["derive"] }
 wasm-bindgen = "0.2.92"
 serde-wasm-bindgen = "0.4"
--- a/bindings/wasm/fix_types.py
+++ b/bindings/wasm/fix_types.py
@@ -63,15 +63,148 @@ style_types = r"""
  getCellStyle(sheet: number, row: number, column: number): CellStyle;
 """.strip()

+view = r"""
+* @returns {any}
+*/
+  getSelectedView(): any;
+""".strip()
+
+view_types = r"""
+* @returns {CellStyle}
+*/
+  getSelectedView(): SelectedView;
+""".strip()
+
+autofill_rows = r"""
+/**
+* @param {any} source_area
+* @param {number} to_row
+*/
+  autoFillRows(source_area: any, to_row: number): void;
+"""
+
+autofill_rows_types = r"""
+/**
+* @param {Area} source_area
+* @param {number} to_row
+*/
+  autoFillRows(source_area: Area, to_row: number): void;
+"""
+
+autofill_columns = r"""
+/**
+* @param {any} source_area
+* @param {number} to_column
+*/
+  autoFillColumns(source_area: any, to_column: number): void;
+"""
+
+autofill_columns_types = r"""
+/**
+* @param {Area} source_area
+* @param {number} to_column
+*/
+  autoFillColumns(source_area: Area, to_column: number): void;
+"""
+
+set_cell_style = r"""
+/**
+* @param {any} styles
+*/
+  onPasteStyles(styles: any): void;
+"""
+
+set_cell_style_types = r"""
+/**
+* @param {CellStyle[][]} styles
+*/
+  onPasteStyles(styles: CellStyle[][]): void;
+"""
+
+set_area_border = r"""
+/**
+* @param {any} area
+* @param {any} border_area
+*/
+  setAreaWithBorder(area: any, border_area: any): void;
+"""
+
+set_area_border_types = r"""
+/**
+* @param {Area} area
+* @param {BorderArea} border_area
+*/
+  setAreaWithBorder(area: Area, border_area: BorderArea): void;
+"""
+
+paste_csv_string = r"""
+/**
+* @param {any} area
+* @param {string} csv
+*/
+  pasteCsvText(area: any, csv: string): void;
+"""
+
+paste_csv_string_types = r"""
+/**
+* @param {Area} area
+* @param {string} csv
+*/
+  pasteCsvText(area: Area, csv: string): void;
+"""
+
+clipboard = r"""
+/**
+* @returns {any}
+*/
+  copyToClipboard(): any;
+"""
+
+clipboard_types = r"""
+/**
+* @returns {Clipboard}
+*/
+  copyToClipboard(): Clipboard;
+"""
+
+paste_from_clipboard = r"""
+/**
+* @param {any} source_range
+* @param {any} clipboard
+* @param {boolean} is_cut
+*/
+  pasteFromClipboard(source_range: any, clipboard: any, is_cut: boolean): void;
+"""
+
+paste_from_clipboard_types = r"""
+/**
+* @param {[number, number, number, number]} source_range
+* @param {ClipboardData} clipboard
+* @param {boolean} is_cut
+*/
+  pasteFromClipboard(source_range: [number, number, number, number], clipboard: ClipboardData, is_cut: boolean): void;
+"""
+
 def fix_types(text):
    text = text.replace(get_tokens_str, get_tokens_str_types)
    text = text.replace(update_style_str, update_style_str_types)
    text = text.replace(properties, properties_types)
    text = text.replace(style, style_types)
+    text = text.replace(view, view_types)
+    text = text.replace(autofill_rows, autofill_rows_types)
+    text = text.replace(autofill_columns, autofill_columns_types)
+    text = text.replace(set_cell_style, set_cell_style_types)
+    text = text.replace(set_area_border, set_area_border_types)
+    text = text.replace(paste_csv_string, paste_csv_string_types)
+    text = text.replace(clipboard, clipboard_types)
+    text = text.replace(paste_from_clipboard, paste_from_clipboard_types)
    with open("types.ts") as f:
        types_str = f.read()
        header_types = "{}\n\n{}".format(header, types_str)
    text = text.replace(header, header_types)
+    if text.find("any") != -1:
+        print("There are 'unfixed' types. Please check.")
+        exit(1)
    return text
    

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Nicolás Hatcher	24dd63b261	FIX: Correct tag number (oops)	2024-11-15 01:07:02 +01:00
Nicolás Hatcher	861700cb45	UPDATE: Adds CHANGELOG	2024-11-15 00:59:13 +01:00
Mehdi Armachi	98dc557a01	Adds navigation labels for sheet management	2024-11-11 10:36:54 +01:00
Nicolás Hatcher	2c2228c2c2	FIX: [App]: Borders done right	2024-10-31 22:43:43 +01:00
Nicolás Hatcher	494a315cbd	FIX: Do geometry right	2024-10-31 22:43:43 +01:00
Nicolás Hatcher	0c69889832	FIX: Column/Row width/height UI issues	2024-10-31 22:43:43 +01:00
Nicolás Hatcher	04d8c658ab	UPDATE: Adds cut/paste	2024-10-31 22:43:43 +01:00
Nicolás Hatcher	dad4755b16	FIX: Fixes from Dani's design	2024-10-26 11:04:52 +02:00
Nicolás Hatcher	75d8a5282e	FIX: Slightly better behaviour for increase/decrease decimal places The general solution must be done in Rust and it is a bit more complex.	2024-10-26 11:04:52 +02:00
Nicolás Hatcher	f78027247b	FIX: Make biome happy	2024-10-26 11:04:52 +02:00
Nicolás Hatcher	ee6a41c4f4	FIX: Nicer loading image	2024-10-26 11:04:52 +02:00
Nicolás Hatcher	b7336f70d6	FIX[App]: Font-size of menu is 12px	2024-10-26 11:04:52 +02:00
Nicolás Hatcher	dae37f14ba	FIX[App]: Over scroll issues	2024-10-26 11:04:52 +02:00
Nicolás Hatcher	7ffbfac432	FIX[WebApp]: fixes in formula bar * fx is not clickable * Removed chevron * Show slecting/ed area in address	2024-10-24 21:54:34 +02:00
Nicolás Hatcher	f9ea4fd757	FIX[WebApp]: Only show the active ranges in the correct sheet Fixes #104	2024-10-24 21:54:34 +02:00
Nicolás Hatcher	7446932519	FIX[WebApp]: Keep the area extended as selected Fixes #110	2024-10-24 21:54:34 +02:00
Nicolás Hatcher	d55845e69f	FIX[WebApp]: PreventDefault when clicking on the Format Editor Fixes #112	2024-10-24 21:54:34 +02:00
Nicolás Hatcher	9e5b959ccc	FIX[WebApp]: Pass the name along to the serve Fixes #111	2024-10-24 21:54:34 +02:00
Nicolás Hatcher	ffa93309e2	FIX: Renaming a sheet with the same name doesn't do anything Fixes #103	2024-10-24 21:54:34 +02:00
Nicolás Hatcher	79216b286b	FIX: Caret color is IronCalc	2024-10-24 21:54:34 +02:00
Nicolás Hatcher	411d4a3780	FIX: Make biome happy	2024-10-24 21:54:34 +02:00
Nicolás Hatcher	3a7aa15347	FIX: Mark code as ununsed for now	2024-10-24 21:54:34 +02:00
Nicolás Hatcher	090e852054	FIX: Make selected sheet bold	2024-10-24 21:54:34 +02:00
Nicolás Hatcher	3e54ad5b3c	FIX: Rename sheet dialog with correct default name Fixes #103	2024-10-24 21:54:34 +02:00
Nicolás Hatcher	7b12c2682e	FIX: Headers height show be the same as the default row height	2024-10-24 21:54:34 +02:00
Nicolás Hatcher	80273a88ec	FIX: When creating a new sheet, select it Fixes #100	2024-10-24 21:54:34 +02:00
Nicolás Hatcher	3d951c5c50	FIX: Several UI fixes from Dani * Toast has Inter font-family * Share button has Inter font family * More accurate menu list to design * Removes unused navigation * Adds link to IronCalc * Removes line=black :O	2024-10-23 22:42:22 +02:00
Nicolás Hatcher	cd54389e91	UPDATE: Implement copy/paste in the UI	2024-10-23 21:43:18 +02:00
Nicolás Hatcher	843d8beb02	FIX: Once again more apparently I don't have anything better to do :D	2024-10-15 19:29:21 +02:00
Nicolás Hatcher	09ac29785d	FIX[wasm]: Fixes failing test	2024-10-15 19:29:21 +02:00
Nicolás Hatcher	2b530423c8	FIX[base]: Adds test for names and row heigh	2024-10-15 19:29:21 +02:00
Nicolás Hatcher	51c41900d7	FIX: Fix broken tests	2024-10-15 19:29:21 +02:00
Nicolás Hatcher	730a815729	FIX[Editor]: More simplifications and fixes	2024-10-15 19:29:21 +02:00
Nicolás Hatcher	9805d0c518	FIX: Set the color of the refe range to be the next from the active ranges	2024-10-15 19:29:21 +02:00
Nicolás Hatcher	10a9d36f3d	FIX: Make biome happy	2024-10-15 19:29:21 +02:00
Nicolás Hatcher	480640dc98	UPDATE[WebApp]: we can now delete models on the localStorage	2024-10-15 19:29:21 +02:00
Nicolás Hatcher	3058a63e4f	FIX: Correct default for vertical align	2024-10-15 19:29:21 +02:00
Nicolás Hatcher	8275d73b64	FIX: Set default row height to 22 This matches the line height. So far a magic number	2024-10-15 19:29:21 +02:00
Nicolás Hatcher	072abb2240	FIX: Vertical Align by default is bottom	2024-10-15 19:29:21 +02:00
Nicolás Hatcher	9a46e5ccc7	FIX: More fixes to the cell editor * Font family is Inter, font size 13, line-width 22 * Correct vertical align for multiline text * Entering multiline text sets the height of the row (!)	2024-10-15 19:29:21 +02:00
Nicolás Hatcher	585e594d8d	FIX: Diverse fixes to the editor * Editor now expands as you write * You can switch between the formula bar and cell editor * While editing in the formula bar you see the results in the editor * Give Mateusz more credit	2024-10-15 19:29:21 +02:00
Nicolás Hatcher	248ef66e7c	FIX: Make biome happy	2024-10-11 21:08:16 +02:00
Nicolás Hatcher	15da2e5785	FIX: Close the sheet list menu when a sheet is selected	2024-10-11 21:08:16 +02:00
Nicolás Hatcher	39174add1f	FIX: number format menu closes when selected	2024-10-11 21:08:16 +02:00
Nicolás Hatcher	e412f5fc22	FIX: Delete the selected area correctly Previously it was deleting one extra row and column	2024-10-11 21:08:16 +02:00
Nicolás Hatcher	42c1a39131	FIX: Cell editor correct behaviour	2024-10-11 21:08:16 +02:00
Nicolás Hatcher	f26cdd3a4b	FIX: Sets the patternFill to solid when changing the background color	2024-10-11 21:08:16 +02:00
Nicolás Hatcher	4016eb5944	FIX: Better support for mobile phones	2024-10-11 21:08:16 +02:00
Nicolás Hatcher	58dfdd329e	FIX: Fix broken build	2024-10-08 23:10:34 +02:00
Nicolás Hatcher	4a290aec7c	FIX: Forgotten file :S	2024-10-08 23:10:34 +02:00
Nicolás Hatcher	3966dbc790	FIX: Correct font-size in navigation bar	2024-10-08 23:10:34 +02:00
Nicolás Hatcher	abd4ce4ea5	FIX: Let’s move the outline handle to left and top 1px	2024-10-08 23:10:34 +02:00
Nicolás Hatcher	02da1eb388	FIX: Make default cells 25% larger	2024-10-08 23:10:34 +02:00
Nicolás Hatcher	1131234531	FIX: Slightly better widths in the row headers I'm afraid this nees to be completely redone	2024-10-08 23:10:34 +02:00
Nicolás Hatcher	b495397b5f	FIX: Proper imports	2024-10-08 23:10:34 +02:00
Nicolás Hatcher	8c0a566995	FIX: Set grid color to grey-300	2024-10-08 23:10:34 +02:00
Nicolás Hatcher	dd62dd2dc6	FIX: Set format menu font-size to 12px	2024-10-08 23:10:34 +02:00
Nicolás Hatcher	79b7b9b817	FIX: Correct paddings in formula bar	2024-10-08 23:10:34 +02:00
Nicolás Hatcher	06ae1a1d6d	FIX: Fix tooltips on buttons * Strike through, * Hide grid lines * all vertical/horizontal align buttons	2024-10-08 23:10:34 +02:00
Nicolás Hatcher	6390739fd4	FIX: Correct height of toolbar (48) and formula bar (40)	2024-10-08 23:10:34 +02:00
Nicolás Hatcher	e41741cf77	FIX: Change border color between toolbox and formula bar to grey-300	2024-10-08 23:10:34 +02:00
Nicolás Hatcher Andrés	48719b6416	UPDATE: Adds cell and formula editing (#92 ) * UPDATE: Adds cell and formula editing * FIX: Do not loose focus when clicking on the formula we are editing * FIX: Minimal implementation of browse mode * FIX: Initial browse mode within sheets * UPDATE: Webapp Minimal Web Application	2024-10-08 19:44:27 +02:00
Nicolás Hatcher Andrés	53d3d5144c	UPDATE: point documentation to app instead of playground (#93 )	2024-09-28 19:23:32 +02:00
Nicolás Hatcher Andrés	bf9a1ed9f4	FIX: Add infrastructure for python tests (#91 ) Also integrated with CI and runs tests in documentation	2024-09-21 15:46:32 +02:00
Nicolás Hatcher Andrés	11df4a55c7	UPDATE: Adds python bindings (#90 ) * UPDATE: Adds python bindings Exclude pyroncalc and wasm from test coverage	2024-09-21 11:58:50 +02:00
Nicolás Hatcher Andrés	00b5b65588	UPDATE: bump version to 0.2.0 (#89 )	2024-09-17 00:27:06 +02:00
Varun Hegde	2b03b3e3b9	Error Handling of public Set functions (#88 ) What are we trying to achieve ? ++ Currently all the major public set functions is panic prone and does not handle and return error. This PR tries to address to all those functions. What major errors that could happen in these functions ? ++ All the functions which are being made as error safe is being tested against invalid sheet, row and column values, which could given by user What are the list of functions whose return type has been altered ? base/src/model.rs 1. update_cell_with_text 2. update_cell_with_bool 3. update_cell_with_number 4. set_user_input 5. get_cell_style_index 6. get_style_for_cell 7. set_cell_with_string ++> New functions being added 1. set_cell_with_boolean 2. set_cell_with_number base/src/styles.rs 1. get_style_with_quote_prefix 3. get_style_with_format 4. get_style_without_quote_prefix 5. get_style base/src/worksheet.rs 1. update_cell 2. set_cell_style 3. set_cell_with_formula 4. set_cell_with_number 6. set_cell_with_string 8. set_cell_with_boolean 9. set_cell_with_error 10. cell_clear_contents 11. cell_clear_contents_with_style ++> Above is the comprehensive list of all functions being ( most are public, some are private ) altered for better error handling. As a side effect of changing function signature, there are many changes being done to other functions ( mostly adding "?" to enable to error propagation further )	2024-09-14 17:37:31 +02:00
Nicolás Hatcher Andrés	83a4431417	FIX[WebApp]: Simplify loading logic of workbook (#87 ) Note that previously the model would have been fetched twice	2024-08-24 06:59:19 +02:00
Nicolás Hatcher Andrés	40aa8bebaf	UPDATE: Adds `load_from_xlsx_bytes` (#86 ) This is usefull if we are transfering bytes, for instance over the internet	2024-08-24 06:50:31 +02:00
Nicolás Hatcher Andrés	b9bf485379	Update README.md (#80 ) We don't need a logo anymore	2024-08-18 12:50:34 +02:00
Nicolás Hatcher Andrés	dc23a7f29c	UPDATE: Adds web app (#79 ) Things missing: * Browse mode * Front end tests * Storybook	2024-08-18 11:44:16 +02:00
Varun Hegde	083548608e	Exporting the Merged Cell : Exports the merged cell properly with testcase to verify the scenario (#76 ) * adding the functionality of exporting the merged cell with testcase to vreify the above enhancement * addressing review comments : 1) moving the testing to appropriate folder 2) fixing lint errors 3) fixing the scenario when merge cell count is 0 * addressing 2nd round review comments : cosmetic fixes * addressing review comments : taking reference instead of cloning	2024-07-21 16:13:58 +02:00
Nicolás Hatcher Andrés	0ba80035d2	FIX: Run test coverage only on Pull Request (#77 )	2024-07-16 07:48:41 +02:00
Nicolás Hatcher Andrés	55a043366a	FIX: Fixes TypeScript types correctly (#75 ) We really need a better way of doing this :/	2024-06-02 19:03:59 +02:00
Nicolás Hatcher Andrés	864a37f1e6	UPDATE: Adds autofill_columns (#74 )	2024-06-02 18:43:43 +02:00
Nicolás Hatcher Andrés	72c7c94f3d	UPDATE: Autofill by rows (#73 )	2024-06-02 10:01:46 +02:00
Nicolás Hatcher Andrés	c3a9b006d2	FIX: Export views and showGridLines properly (#72 )	2024-05-28 21:52:10 +02:00
Nicolás Hatcher Andrés	b37397acb8	UPDATE: Adds ability to show/hide grid lines (#71 )	2024-05-26 21:28:00 +02:00
Nicolás Hatcher Andrés	49c3b14bf0	UPDATE: Adds get/set views to the user model API (#69 )	2024-05-20 17:51:09 +02:00
Nicolás Hatcher Andrés	d2cba48f8e	FIX: Fixes incorrect result in M1 Apple silicom (#68 )	2024-05-19 10:34:57 +02:00
Nicolás Hatcher Andrés	f752c90058	UPDATE: Parses selected row/column/range and selected sheet (#67 ) * FIX: Update to Rust 1.78.0 * UPDATE: Parses selected row/column/range and selected sheet	2024-05-09 11:46:26 +02:00
Daniel González-Albo	a78d5593f2	Merge pull request #60 from ironcalc/feature/dani-logo UPDATE: adds missing favicons	2024-04-27 18:11:29 +02:00
Daniel	079208a1bd	UPDATE: adds missing favicons	2024-04-27 18:02:04 +02:00
Daniel González-Albo	4721582dfe	Merge pull request #42 from ironcalc/feature/dani-logo UPDATE: adds logo	2024-04-25 19:49:43 +02:00
Daniel	1746eec5da	UPDATE: adds logo	2024-04-25 19:42:10 +02:00
Nicolás Hatcher Andrés	f9cf86a17c	Bugfix/nicolas more fixes (#36 ) * FIX: Remove the serde_json depndendency * UPDATE: Use binary representation also for languages and locales	2024-04-15 19:25:38 +02:00
Nicolás Hatcher Andrés	49ef846ebd	FIX: small diverse fixes (#35 )	2024-04-14 21:50:14 +02:00
				`@@ -0,0 +1 @@`
				`PfrendeesD<>VRAITRUEWAHRVERDADEROTVFAUXFALSEFALSCHFALSOUw#REF!#REF!#BEZUG!#¡REF!e<>#NOM?#NAME?#NAME?#¿NOMBRE?x<>#VALEUR!#VALUE!#WERT!#¡VALOR!w<>#DIV/0!#DIV/0!#DIV/0!#¡DIV/0!<04>#N/A#N/A#NV#N/AXv#NOMBRE!#NUM!#ZAHL!#¡NUM!<02><>#N/IMPL!#N/IMPL!#N/IMPL!#N/IMPL!w{#SPILL!#SPILL!#ÜBERLAUF!#SPILL!ff#CALC!#CALC!#CALC!#CALC!ff#CIRC!#CIRC!#CIRC!#CIRC!ww#ERROR!#ERROR!#ERROR!#ERROR!ff#NULL!#NULL!#NULL!#NULL!`