From 45c081c51236f1e7590ce1a9c1f022f471f3f86c Mon Sep 17 00:00:00 2001
From: Jeremy Wall <Jeremy@marzhillstudios.com>
Date: Sun, 19 Jan 2025 16:49:42 -0500
Subject: [PATCH 1/7] wip: refactor cell styling into a separte method.

---
 src/ui/render/viewport.rs | 40 +++++++++++++++++++++------------------
 1 file changed, 22 insertions(+), 18 deletions(-)

diff --git a/src/ui/render/viewport.rs b/src/ui/render/viewport.rs
index c91d975..0651771 100644
--- a/src/ui/render/viewport.rs
+++ b/src/ui/render/viewport.rs
@@ -159,24 +159,7 @@ impl<'ws> Viewport<'ws> {
                                 .book
                                 .get_cell_addr_rendered(&Address { row: ri, col: *ci })
                                 .unwrap();
-                            let mut cell = Cell::new(Text::raw(content));
-                            if let Some((start, end)) =
-                                &self.range_selection.map_or(None, |r| r.get_range())
-                            {
-                                if ri >= start.row
-                                    && ri <= end.row
-                                    && *ci >= start.col
-                                    && *ci <= end.col
-                                {
-                                    // This is a selected range
-                                    cell = cell.fg(Color::Black).bg(Color::LightBlue)
-                                }
-                            }
-                            match (self.book.location.row == ri, self.book.location.col == *ci) {
-                                (true, true) => cell.fg(Color::White).bg(Color::Rgb(57, 61, 71)),
-                                _ => cell,
-                            }
-                            .bold()
+                            self.compute_cell_style(ri, ci, Cell::new(Text::raw(content)))
                         },
                     ));
                     Row::new(cells)
@@ -208,6 +191,27 @@ impl<'ws> Viewport<'ws> {
             .column_spacing(0)
             .flex(Flex::Start))
     }
+
+    fn compute_cell_style<'widget>(&self, ri: usize, ci: &usize, mut cell: Cell<'widget>) -> Cell<'widget> {
+        if let Some((start, end)) =
+            &self.range_selection.map_or(None, |r| r.get_range())
+        {
+            if ri >= start.row
+                && ri <= end.row
+                && *ci >= start.col
+                && *ci <= end.col
+            {
+                // This is a selected range
+                cell = cell.fg(Color::Black).bg(Color::LightBlue)
+            }
+        }
+        match (self.book.location.row == ri, self.book.location.col == *ci) {
+            (true, true) => cell.fg(Color::White).bg(Color::Rgb(57, 61, 71)),
+            // TODO(zaphar): Support ironcalc style options
+            _ => cell,
+        }
+        .bold()
+    }
 }
 
 impl<'ws> StatefulWidget for Viewport<'ws> {

From 9db2eb91ad8139daa326496813199c56ae869415 Mon Sep 17 00:00:00 2001
From: Jeremy Wall <Jeremy@marzhillstudios.com>
Date: Sun, 19 Jan 2025 17:57:51 -0500
Subject: [PATCH 2/7] wip: color mapping from style color names

---
 Cargo.lock                |  7 ++++++
 Cargo.toml                |  1 +
 src/book/mod.rs           | 13 +++++++++-
 src/ui/render/test.rs     | 28 +++++++++++++++++++++
 src/ui/render/viewport.rs | 52 +++++++++++++++++++++++++++++++++++----
 5 files changed, 95 insertions(+), 6 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index e096f7e..f7d3e8f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -369,6 +369,12 @@ version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990"
 
+[[package]]
+name = "colorsys"
+version = "0.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54261aba646433cb567ec89844be4c4825ca92a4f8afba52fc4dd88436e31bbd"
+
 [[package]]
 name = "compact_str"
 version = "0.8.0"
@@ -1483,6 +1489,7 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "clap",
+ "colorsys",
  "crossterm",
  "csvx",
  "futures",
diff --git a/Cargo.toml b/Cargo.toml
index d337a2a..5da5cb0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -19,3 +19,4 @@ tui-prompts = "0.5.0"
 slice-utils = { git = "https://dev.zaphar.net/zaphar/slice-cursor-rs.git", ref = "main" }
 tui-popup = "0.6.0"
 serde_json = "1.0.133"
+colorsys = "0.6.7"
diff --git a/src/book/mod.rs b/src/book/mod.rs
index 91c11b9..e2c2103 100644
--- a/src/book/mod.rs
+++ b/src/book/mod.rs
@@ -3,7 +3,7 @@ use std::cmp::max;
 use anyhow::{anyhow, Result};
 use ironcalc::{
     base::{
-        types::{SheetData, Worksheet},
+        types::{CellStyleXfs, CellStyles, SheetData, Style, Worksheet},
         worksheet::WorksheetDimension,
         Model,
     },
@@ -240,6 +240,17 @@ impl Book {
         Ok(self.get_cell_addr_rendered(&self.location)?)
     }
 
+    pub fn get_cell_style(&self, sheet: u32, cell: &Address) -> Option<Style> {
+        // TODO(jwall): This is modeled a little weird. We should probably record
+        // the error *somewhere* but for the user there is nothing to be done except
+        // not use a style.
+        match self.model.get_style_for_cell(sheet, cell.row as i32, cell.col as i32)
+        {
+            Err(e) => None,
+            Ok(s) => Some(s),
+        }
+    }
+
     /// Get a cells rendered content for display.
     pub fn get_cell_addr_rendered(&self, Address { row, col }: &Address) -> Result<String> {
         Ok(self
diff --git a/src/ui/render/test.rs b/src/ui/render/test.rs
index 46c42cf..dc253aa 100644
--- a/src/ui/render/test.rs
+++ b/src/ui/render/test.rs
@@ -1,4 +1,5 @@
 use ironcalc::base::Model;
+use ratatui::style::Color;
 
 use crate::ui::AppState;
 
@@ -73,3 +74,30 @@ fn test_viewport_visible_columns_after_length_change() {
         assert_eq!(1, cols.last().expect("Failed to get last column").idx);
     }
 }
+
+#[test]
+fn test_color_mapping() {
+    for (s, c) in [
+        ("red", Color::Red),
+        ("blue", Color::Blue),
+        ("green", Color::Green),
+        ("magenta", Color::Magenta),
+        ("cyan", Color::Cyan),
+        ("white", Color::White),
+        ("yellow", Color::Yellow),
+        ("black", Color::Black),
+        ("gray", Color::Gray),
+        ("grey", Color::Gray),
+        ("lightred", Color::LightRed),
+        ("lightblue", Color::LightBlue),
+        ("lightgreen", Color::LightGreen),
+        ("lightmagenta", Color::LightMagenta),
+        ("lightcyan", Color::LightCyan),
+        ("lightyellow", Color::LightYellow),
+        ("darkgrey", Color::DarkGray),
+        ("darkgray", Color::DarkGray),
+        ("#35f15b", Color::Rgb(53, 241, 91)),
+    ].map(|(s, c)| (Some(s.to_string()), c)) {
+        assert_eq!(super::viewport::map_color(s.as_ref(), Color::Gray), c);
+    }
+}
diff --git a/src/ui/render/viewport.rs b/src/ui/render/viewport.rs
index 0651771..06b6176 100644
--- a/src/ui/render/viewport.rs
+++ b/src/ui/render/viewport.rs
@@ -159,7 +159,7 @@ impl<'ws> Viewport<'ws> {
                                 .book
                                 .get_cell_addr_rendered(&Address { row: ri, col: *ci })
                                 .unwrap();
-                            self.compute_cell_style(ri, ci, Cell::new(Text::raw(content)))
+                            self.compute_cell_style(ri, *ci, Cell::new(Text::raw(content)))
                         },
                     ));
                     Row::new(cells)
@@ -192,20 +192,25 @@ impl<'ws> Viewport<'ws> {
             .flex(Flex::Start))
     }
 
-    fn compute_cell_style<'widget>(&self, ri: usize, ci: &usize, mut cell: Cell<'widget>) -> Cell<'widget> {
+    fn compute_cell_style<'widget>(&self, ri: usize, ci: usize, mut cell: Cell<'widget>) -> Cell<'widget> {
+        let style = self.book.get_cell_style(self.book.current_sheet, &Address { row: ri, col: ci, });
+        let bg_color = map_color(style.as_ref().map(|s| s.fill.bg_color.as_ref()).flatten(), Color::Rgb(35, 33, 54));
+        let fg_color = map_color(style.as_ref().map(|s| s.fill.fg_color.as_ref()).flatten(), Color::White);
         if let Some((start, end)) =
             &self.range_selection.map_or(None, |r| r.get_range())
         {
             if ri >= start.row
                 && ri <= end.row
-                && *ci >= start.col
-                && *ci <= end.col
+                && ci >= start.col
+                && ci <= end.col
             {
                 // This is a selected range
                 cell = cell.fg(Color::Black).bg(Color::LightBlue)
             }
+        } else {
+            cell = cell.bg(bg_color).fg(fg_color);
         }
-        match (self.book.location.row == ri, self.book.location.col == *ci) {
+        match (self.book.location.row == ri, self.book.location.col == ci) {
             (true, true) => cell.fg(Color::White).bg(Color::Rgb(57, 61, 71)),
             // TODO(zaphar): Support ironcalc style options
             _ => cell,
@@ -214,6 +219,43 @@ impl<'ws> Viewport<'ws> {
     }
 }
 
+pub(crate) fn map_color(color: Option<&String>, otherwise: Color) -> Color {
+    color.map(|s| match s.to_lowercase().as_str() {
+        "red" => Color::Red,
+        "blue" => Color::Blue,
+        "green" => Color::Green,
+        "magenta" => Color::Magenta,
+        "cyan" => Color::Cyan,
+        "white" => Color::White,
+        "yellow" => Color::Yellow,
+        "black" => Color::Black,
+        "gray" | "grey" => Color::Gray,
+        "lightred" => Color::LightRed,
+        "lightblue" => Color::LightBlue,
+        "lightgreen" => Color::LightGreen,
+        "lightmagenta" => Color::LightMagenta,
+        "lightcyan" => Color::LightCyan,
+        "lightyellow" => Color::LightYellow,
+        "darkgrey" | "darkgray" => Color::DarkGray,
+        candidate => {
+            // TODO(jeremy): Should we support more syntaxes than hex string?
+            // hsl(...) ??
+            // rgb(...) ??
+            if candidate.starts_with("#") {
+                if let Ok(rgb) = colorsys::Rgb::from_hex_str(candidate) {
+                    // Note that the colorsys rgb model clamps the f64 values to no more 
+                    // than 255.0 so the below casts are safe.
+                    Color::Rgb(rgb.red() as u8, rgb.green() as u8, rgb.blue() as u8)
+                } else {
+                    otherwise
+                }
+            } else {
+                otherwise
+            }
+        }
+    }).unwrap_or(otherwise)
+}
+
 impl<'ws> StatefulWidget for Viewport<'ws> {
     type State = ViewportState;
 

From 8f07e8c0e7c8502baf5b28547b47b7082bb15d26 Mon Sep 17 00:00:00 2001
From: Jeremy Wall <jeremy@marzhillstudios.com>
Date: Wed, 22 Jan 2025 18:18:38 -0500
Subject: [PATCH 3/7] wip: the beginnings of ui for modifying colors

---
 src/book/mod.rs |  6 ++++++
 src/ui/cmd.rs   | 28 ++++++++++++++++++++++++++++
 src/ui/mod.rs   | 15 +++++++++++++++
 3 files changed, 49 insertions(+)

diff --git a/src/book/mod.rs b/src/book/mod.rs
index e2c2103..13b03da 100644
--- a/src/book/mod.rs
+++ b/src/book/mod.rs
@@ -251,6 +251,12 @@ impl Book {
         }
     }
 
+    pub fn set_cell_style(&mut self, style: &Style, sheet: u32, cell: &Address) -> Result<()> {
+        self.model.set_cell_style(sheet, cell.row as i32, cell.col as i32, style)
+            .map_err(|s| anyhow!("Unable to format cell {}", s))?;
+        Ok(())
+    }
+
     /// Get a cells rendered content for display.
     pub fn get_cell_addr_rendered(&self, Address { row, col }: &Address) -> Result<String> {
         Ok(self
diff --git a/src/ui/cmd.rs b/src/ui/cmd.rs
index edaeed3..225878f 100644
--- a/src/ui/cmd.rs
+++ b/src/ui/cmd.rs
@@ -7,6 +7,9 @@ pub enum Cmd<'a> {
     Write(Option<&'a str>),
     InsertRows(usize),
     InsertColumns(usize),
+    ColorRows(usize, &'a str),
+    ColorColumns(usize, &'a str),
+    ColorCell(&'a str),
     RenameSheet(Option<usize>, &'a str),
     NewSheet(Option<&'a str>),
     SelectSheet(&'a str),
@@ -51,6 +54,9 @@ pub fn parse<'cmd, 'i: 'cmd>(input: &'i str) -> Result<Option<Cmd<'cmd>>, &'stat
     if let Some(cmd) = try_consume_rename_sheet(cursor.clone())? {
         return Ok(Some(cmd));
     }
+    if let Some(cmd) = try_consume_color_cell(cursor.clone())? {
+        return Ok(Some(cmd));
+    }
     Ok(None)
 }
 
@@ -138,6 +144,28 @@ fn try_consume_select_sheet<'cmd, 'i: 'cmd>(
     return Ok(Some(Cmd::SelectSheet(arg)));
 }
 
+fn try_consume_color_cell<'cmd, 'i: 'cmd>(
+    mut input: StrCursor<'i>,
+) -> Result<Option<Cmd<'cmd>>, &'static str> {
+    const SHORT: &'static str = "cc";
+    const LONG: &'static str = "color-cell";
+    if compare(input.clone(), LONG) {
+        input.seek(LONG.len());
+    } else if compare(input.clone(), SHORT) {
+        input.seek(SHORT.len());
+    } else {
+        return Ok(None);
+    };
+    if input.remaining() > 0 && !is_ws(&mut input) {
+        return Err("Invalid command: Did you mean to type `color-cell <color>`?");
+    }
+    let arg = input.span(0..).trim();
+    if arg.len() == 0 {
+        return Err("Invalid command: Did you mean to type `color-cell <color>`?");
+    }
+    return Ok(Some(Cmd::ColorCell(arg)));
+}
+
 fn try_consume_insert_row<'cmd, 'i: 'cmd>(
     mut input: StrCursor<'i>,
 ) -> Result<Option<Cmd<'cmd>>, &'static str> {
diff --git a/src/ui/mod.rs b/src/ui/mod.rs
index 71bfb4b..4967ef5 100644
--- a/src/ui/mod.rs
+++ b/src/ui/mod.rs
@@ -465,6 +465,21 @@ impl<'ws> Workspace<'ws> {
             Ok(Some(Cmd::Quit)) => {
                 Ok(Some(ExitCode::SUCCESS))
             }
+            Ok(Some(Cmd::ColorRows(_count, _color))) => {
+                Ok(Some(ExitCode::FAILURE))
+            }
+            Ok(Some(Cmd::ColorColumns(_count, _color))) => {
+                Ok(Some(ExitCode::FAILURE))
+            }
+            Ok(Some(Cmd::ColorCell(color))) => {
+                let address = self.book.location.clone();
+                let sheet = self.book.current_sheet;
+                let mut style = self.book.get_cell_style(sheet, &address)
+                    .expect("I think this should be impossible.").clone();
+                style.fill.bg_color = Some(color.to_string());
+                self.book.set_cell_style(&style, sheet, &address)?;
+                Ok(None)
+            }
             Ok(None) => {
                 self.enter_dialog_mode(vec![format!("Unrecognized commmand {}", cmd_text)]);
                 Ok(None)

From d52bf70cc3af91d18f57d65c91a282ec777c55df Mon Sep 17 00:00:00 2001
From: Jeremy Wall <Jeremy@marzhillstudios.com>
Date: Sat, 25 Jan 2025 11:19:02 -0500
Subject: [PATCH 4/7] wip: color styling commands for rows and cols

---
 src/ui/cmd.rs  | 52 +++++++++++++++++++++++++++++++++++++++++++++++---
 src/ui/test.rs | 45 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 94 insertions(+), 3 deletions(-)

diff --git a/src/ui/cmd.rs b/src/ui/cmd.rs
index 225878f..2a4e092 100644
--- a/src/ui/cmd.rs
+++ b/src/ui/cmd.rs
@@ -7,8 +7,8 @@ pub enum Cmd<'a> {
     Write(Option<&'a str>),
     InsertRows(usize),
     InsertColumns(usize),
-    ColorRows(usize, &'a str),
-    ColorColumns(usize, &'a str),
+    ColorRows(Option<usize>, &'a str),
+    ColorColumns(Option<usize>, &'a str),
     ColorCell(&'a str),
     RenameSheet(Option<usize>, &'a str),
     NewSheet(Option<&'a str>),
@@ -54,6 +54,12 @@ pub fn parse<'cmd, 'i: 'cmd>(input: &'i str) -> Result<Option<Cmd<'cmd>>, &'stat
     if let Some(cmd) = try_consume_rename_sheet(cursor.clone())? {
         return Ok(Some(cmd));
     }
+    if let Some(cmd) = try_consume_color_rows(cursor.clone())? {
+        return Ok(Some(cmd));
+    }
+    if let Some(cmd) = try_consume_color_columns(cursor.clone())? {
+        return Ok(Some(cmd));
+    }
     if let Some(cmd) = try_consume_color_cell(cursor.clone())? {
         return Ok(Some(cmd));
     }
@@ -306,11 +312,51 @@ fn try_consume_rename_sheet<'cmd, 'i: 'cmd>(
     let (idx, rest) = try_consume_usize(input.clone());
     let arg = rest.span(0..).trim();
     if arg.is_empty() {
-        return Err("Invalid command: `rename-sheet` requires a sheet name argument?");
+        return Err("Invalid command: `rename-sheet` requires a sheet name argument");
     }
     return Ok(Some(Cmd::RenameSheet(idx, arg)));
 }
 
+fn try_consume_color_rows<'cmd, 'i: 'cmd>(
+    mut input: StrCursor<'i>,
+) -> Result<Option<Cmd<'cmd>>, &'static str> {
+    const LONG: &'static str = "color-rows";
+    if compare(input.clone(), LONG) {
+        input.seek(LONG.len());
+    } else {
+        return Ok(None);
+    }
+    if input.remaining() > 0 && !is_ws(&mut input) {
+        return Err("Invalid command: Did you mean to type `color-rows [count] <color>`?");
+    }
+    let (idx, rest) = try_consume_usize(input.clone());
+    let arg = rest.span(0..).trim();
+    if arg.is_empty() {
+        return Err("Invalid command: `color-rows` requires a color argument");
+    }
+    return Ok(Some(Cmd::ColorRows(idx, arg)));
+}
+
+fn try_consume_color_columns<'cmd, 'i: 'cmd>(
+    mut input: StrCursor<'i>,
+) -> Result<Option<Cmd<'cmd>>, &'static str> {
+    const LONG: &'static str = "color-columns";
+    if compare(input.clone(), LONG) {
+        input.seek(LONG.len());
+    } else {
+        return Ok(None);
+    }
+    if input.remaining() > 0 && !is_ws(&mut input) {
+        return Err("Invalid command: Did you mean to type `color-columns [count] <color>`?");
+    }
+    let (idx, rest) = try_consume_usize(input.clone());
+    let arg = rest.span(0..).trim();
+    if arg.is_empty() {
+        return Err("Invalid command: `color-columns` requires a color argument");
+    }
+    return Ok(Some(Cmd::ColorColumns(idx, arg)));
+}
+
 fn try_consume_usize<'cmd, 'i: 'cmd>(
     mut input: StrCursor<'i>,
 ) -> (Option<usize>, StrCursor<'i>) {
diff --git a/src/ui/test.rs b/src/ui/test.rs
index 90df20d..5f22d0f 100644
--- a/src/ui/test.rs
+++ b/src/ui/test.rs
@@ -259,6 +259,51 @@ fn test_cmd_rename_sheet_with_idx_and_name() {
     assert_eq!(cmd, Cmd::RenameSheet(Some(0), "test"));
 }
 
+#[test]
+fn test_cmd_color_rows_with_color() {
+    let input = "color-rows red";
+    let result = parse(input);
+    assert!(result.is_ok());
+    let output = result.unwrap();
+    assert!(output.is_some());
+    let cmd = output.unwrap();
+    assert_eq!(cmd, Cmd::ColorRows(None, "red"));
+}
+
+#[test]
+fn test_cmd_color_rows_with_idx_and_color() {
+    let input = "color-rows 1 red";
+    let result = parse(input);
+    assert!(result.is_ok());
+    let output = result.unwrap();
+    assert!(output.is_some());
+    let cmd = output.unwrap();
+    assert_eq!(cmd, Cmd::ColorRows(Some(1), "red"));
+}
+
+#[test]
+fn test_cmd_color_columns_with_color() {
+    let input = "color-columns red";
+    let result = parse(input);
+    assert!(result.is_ok());
+    let output = result.unwrap();
+    assert!(output.is_some());
+    let cmd = output.unwrap();
+    assert_eq!(cmd, Cmd::ColorColumns(None, "red"));
+}
+
+#[test]
+fn test_cmd_color_columns_with_idx_and_color() {
+    let input = "color-columns 1 red";
+    let result = parse(input);
+    assert!(result.is_ok());
+    let output = result.unwrap();
+    assert!(output.is_some());
+    let cmd = output.unwrap();
+    assert_eq!(cmd, Cmd::ColorColumns(Some(1), "red"));
+}
+
+
 #[test]
 fn test_input_navitation_enter_key() {
     let mut ws = new_workspace();

From e0c6896d615ae71f0479f13c242fc08b2ff58511 Mon Sep 17 00:00:00 2001
From: Jeremy Wall <Jeremy@marzhillstudios.com>
Date: Sat, 25 Jan 2025 18:56:47 -0500
Subject: [PATCH 5/7] wip: actually color the rows and columns

---
 src/book/mod.rs | 95 +++++++++++++++++++++++++++++++++++++++++++++++--
 src/ui/mod.rs   | 20 +++++++++--
 2 files changed, 111 insertions(+), 4 deletions(-)

diff --git a/src/book/mod.rs b/src/book/mod.rs
index 13b03da..36aaab6 100644
--- a/src/book/mod.rs
+++ b/src/book/mod.rs
@@ -3,7 +3,7 @@ use std::cmp::max;
 use anyhow::{anyhow, Result};
 use ironcalc::{
     base::{
-        types::{CellStyleXfs, CellStyles, SheetData, Style, Worksheet},
+        types::{Border, Col, Fill, Font, Row, SheetData, Style, Worksheet},
         worksheet::WorksheetDimension,
         Model,
     },
@@ -246,17 +246,108 @@ impl Book {
         // not use a style.
         match self.model.get_style_for_cell(sheet, cell.row as i32, cell.col as i32)
         {
-            Err(e) => None,
+            Err(_) => None,
             Ok(s) => Some(s),
         }
     }
 
+    fn get_column(&self, sheet: u32, col: usize) -> Result<Option<&Col>> {
+        Ok(self.model.workbook.worksheet(sheet)
+            .map_err(|e| anyhow!("{}", e))?.cols.get(col))
+    }
+
+    fn get_row(&self, sheet: u32, col: usize) -> Result<Option<&Row>> {
+        Ok(self.model.workbook.worksheet(sheet)
+            .map_err(|e| anyhow!("{}", e))?.rows.get(col))
+    }
+
+    pub fn get_column_style(&self, sheet: u32, col: usize) -> Result<Option<Style>> {
+        // TODO(jwall): This is modeled a little weird. We should probably record
+        // the error *somewhere* but for the user there is nothing to be done except
+        // not use a style.
+        if let Some(col) = self.get_column(sheet, col)? {
+            if let Some(style_idx) = col.style.map(|idx| idx as usize) {
+                let styles = &self.model.workbook.styles;
+                if styles.cell_style_xfs.len() <= style_idx {
+                    return Ok(Some(Style {
+                        alignment: None,
+                        num_fmt: styles.num_fmts[style_idx].format_code.clone(),
+                        fill: styles.fills[style_idx].clone(),
+                        font: styles.fonts[style_idx].clone(),
+                        border: styles.borders[style_idx].clone(),
+                        quote_prefix: false,
+                    }));
+                }
+            }
+        }
+        return Ok(None);
+    }
+
+    pub fn get_row_style(&self, sheet: u32, row: usize) -> Result<Option<Style>> {
+        // TODO(jwall): This is modeled a little weird. We should probably record
+        // the error *somewhere* but for the user there is nothing to be done except
+        // not use a style.
+        if let Some(row) = self.get_row(sheet, row)? {
+            let style_idx = row.s as usize;
+            let styles = &self.model.workbook.styles;
+            if styles.cell_style_xfs.len() <= style_idx {
+                return Ok(Some(Style {
+                    alignment: None,
+                    num_fmt: styles.num_fmts[style_idx].format_code.clone(),
+                    fill: styles.fills[style_idx].clone(),
+                    font: styles.fonts[style_idx].clone(),
+                    border: styles.borders[style_idx].clone(),
+                    quote_prefix: false,
+                }));
+            }
+        }
+        return Ok(None);
+    }
+
+    pub fn create_style(&mut self) -> Style {
+        Style {
+            alignment: None,
+            num_fmt: String::new(),
+            fill: Fill::default(),
+            font: Font::default(),
+            border: Border::default(),
+            quote_prefix: false,
+        }
+    }
+
     pub fn set_cell_style(&mut self, style: &Style, sheet: u32, cell: &Address) -> Result<()> {
         self.model.set_cell_style(sheet, cell.row as i32, cell.col as i32, style)
             .map_err(|s| anyhow!("Unable to format cell {}", s))?;
         Ok(())
     }
 
+    pub fn set_col_style(&mut self, style: &Style, sheet: u32, col: usize) -> Result<()> {
+        let idx = self.create_or_get_style_idx(style);
+        self.model.workbook.worksheet_mut(sheet)
+            .map_err(|e| anyhow!("{}", e))?
+            .set_column_style(col as i32, idx)
+            .map_err(|e| anyhow!("{}", e))?;
+        Ok(())
+    }
+
+    pub fn set_row_style(&mut self, style: &Style, sheet: u32, row: usize) -> Result<()> {
+        let idx = self.create_or_get_style_idx(style);
+        self.model.workbook.worksheet_mut(sheet)
+            .map_err(|e| anyhow!("{}", e))?
+            .set_row_style(row as i32, idx)
+            .map_err(|e| anyhow!("{}", e))?;
+        Ok(())
+    }
+
+    fn create_or_get_style_idx(&mut self, style: &Style) -> i32 {
+        let idx = if let Some(style_idx) = self.model.workbook.styles.get_style_index(style) {
+            style_idx
+        } else {
+            self.model.workbook.styles.create_new_style(style)
+        };
+        idx
+    }
+
     /// Get a cells rendered content for display.
     pub fn get_cell_addr_rendered(&self, Address { row, col }: &Address) -> Result<String> {
         Ok(self
diff --git a/src/ui/mod.rs b/src/ui/mod.rs
index 4967ef5..a6b46b0 100644
--- a/src/ui/mod.rs
+++ b/src/ui/mod.rs
@@ -466,10 +466,26 @@ impl<'ws> Workspace<'ws> {
                 Ok(Some(ExitCode::SUCCESS))
             }
             Ok(Some(Cmd::ColorRows(_count, _color))) => {
-                Ok(Some(ExitCode::FAILURE))
+                let row = self.book.location.row;
+                let mut style = if let Some(style) = self.book.get_row_style(self.book.current_sheet, row)? {
+                    style
+                } else {
+                    self.book.create_style()
+                };
+                style.fill.bg_color = Some(_color.to_string());
+                self.book.set_row_style(&style, self.book.current_sheet, row)?;
+                Ok(None)
             }
             Ok(Some(Cmd::ColorColumns(_count, _color))) => {
-                Ok(Some(ExitCode::FAILURE))
+                let col = self.book.location.col;
+                let mut style = if let Some(style) = self.book.get_column_style(self.book.current_sheet, col)? {
+                    style
+                } else {
+                    self.book.create_style()
+                };
+                style.fill.bg_color = Some(_color.to_string());
+                self.book.set_col_style(&style, self.book.current_sheet, col)?;
+                Ok(None)
             }
             Ok(Some(Cmd::ColorCell(color))) => {
                 let address = self.book.location.clone();

From b6b98bc0994aa88ee46d63f27445d2226ffa1a30 Mon Sep 17 00:00:00 2001
From: Jeremy Wall <jeremy@marzhillstudios.com>
Date: Sun, 26 Jan 2025 19:14:30 -0500
Subject: [PATCH 6/7] wip: preserve the column width when setting style

---
 src/book/mod.rs | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/book/mod.rs b/src/book/mod.rs
index 36aaab6..e454cd4 100644
--- a/src/book/mod.rs
+++ b/src/book/mod.rs
@@ -323,9 +323,13 @@ impl Book {
 
     pub fn set_col_style(&mut self, style: &Style, sheet: u32, col: usize) -> Result<()> {
         let idx = self.create_or_get_style_idx(style);
-        self.model.workbook.worksheet_mut(sheet)
-            .map_err(|e| anyhow!("{}", e))?
-            .set_column_style(col as i32, idx)
+        let sheet = self.model.workbook.worksheet_mut(sheet)
+            .map_err(|e| anyhow!("{}", e))?;
+        let width = sheet.get_column_width(col as i32)
+            .map_err(|e| anyhow!("{}", e))?;
+        sheet.set_column_style(col as i32, idx)
+            .map_err(|e| anyhow!("{}", e))?;
+        sheet.set_column_width(col as i32, width)
             .map_err(|e| anyhow!("{}", e))?;
         Ok(())
     }

From aa0a1512f65438ea45314cdcdd15cb20bda8a8d5 Mon Sep 17 00:00:00 2001
From: Jeremy Wall <jeremy@marzhillstudios.com>
Date: Tue, 28 Jan 2025 21:10:39 -0500
Subject: [PATCH 7/7] wip: handle ranges and multiple columns or rows

---
 src/ui/mod.rs             |  66 ++++++++++++++++---------
 src/ui/render/viewport.rs | 101 ++++++++++++++++++++++----------------
 2 files changed, 103 insertions(+), 64 deletions(-)

diff --git a/src/ui/mod.rs b/src/ui/mod.rs
index a6b46b0..ac85fc7 100644
--- a/src/ui/mod.rs
+++ b/src/ui/mod.rs
@@ -465,35 +465,54 @@ impl<'ws> Workspace<'ws> {
             Ok(Some(Cmd::Quit)) => {
                 Ok(Some(ExitCode::SUCCESS))
             }
-            Ok(Some(Cmd::ColorRows(_count, _color))) => {
+            Ok(Some(Cmd::ColorRows(_count, color))) => {
+                let row_count = _count.unwrap_or(1);
                 let row = self.book.location.row;
-                let mut style = if let Some(style) = self.book.get_row_style(self.book.current_sheet, row)? {
-                    style
-                } else {
-                    self.book.create_style()
-                };
-                style.fill.bg_color = Some(_color.to_string());
-                self.book.set_row_style(&style, self.book.current_sheet, row)?;
+                for r in row..(row+row_count) {
+                    let mut style = if let Some(style) = self.book.get_row_style(self.book.current_sheet, r)? {
+                        style
+                    } else {
+                        self.book.create_style()
+                    };
+                    style.fill.bg_color = Some(color.to_string());
+                    self.book.set_row_style(&style, self.book.current_sheet, r)?;
+                }
                 Ok(None)
             }
-            Ok(Some(Cmd::ColorColumns(_count, _color))) => {
+            Ok(Some(Cmd::ColorColumns(_count, color))) => {
+                let col_count = _count.unwrap_or(1);
                 let col = self.book.location.col;
-                let mut style = if let Some(style) = self.book.get_column_style(self.book.current_sheet, col)? {
-                    style
-                } else {
-                    self.book.create_style()
-                };
-                style.fill.bg_color = Some(_color.to_string());
-                self.book.set_col_style(&style, self.book.current_sheet, col)?;
+                for c in col..(col+col_count) {
+                    let mut style = if let Some(style) = self.book.get_column_style(self.book.current_sheet, c)? {
+                        style
+                    } else {
+                        self.book.create_style()
+                    };
+                    style.fill.bg_color = Some(color.to_string());
+                    self.book.set_col_style(&style, self.book.current_sheet, c)?;
+                }
                 Ok(None)
             }
             Ok(Some(Cmd::ColorCell(color))) => {
-                let address = self.book.location.clone();
-                let sheet = self.book.current_sheet;
-                let mut style = self.book.get_cell_style(sheet, &address)
-                    .expect("I think this should be impossible.").clone();
-                style.fill.bg_color = Some(color.to_string());
-                self.book.set_cell_style(&style, sheet, &address)?;
+                if let Some((start, end)) = self.state.range_select.get_range() {
+                    for ri in start.row..=end.row {
+                        for ci in start.col..=end.col {
+                            let address = Address { row: ri, col: ci };
+                            let sheet = self.book.current_sheet;
+                            let mut style = self.book.get_cell_style(sheet, &address)
+                                .expect("I think this should be impossible.").clone();
+                            style.fill.bg_color = Some(color.to_string());
+                            self.book.set_cell_style(&style, sheet, &address)?;
+                        }
+                    }
+                } else {
+                    let address = self.book.location.clone();
+                    let sheet = self.book.current_sheet;
+                    let mut style = self.book.get_cell_style(sheet, &address)
+                        .expect("I think this should be impossible.").clone();
+                    style.fill.bg_color = Some(color.to_string());
+                    self.book.set_cell_style(&style, sheet, &address)?;
+                }
                 Ok(None)
             }
             Ok(None) => {
@@ -630,6 +649,9 @@ impl<'ws> Workspace<'ws> {
                     }
                     self.exit_range_select_mode()?;
                 }
+                KeyCode::Char(':') => {
+                    self.enter_command_mode();
+                }
                 _ => {
                     // moop
                 }
diff --git a/src/ui/render/viewport.rs b/src/ui/render/viewport.rs
index 06b6176..e37e8f8 100644
--- a/src/ui/render/viewport.rs
+++ b/src/ui/render/viewport.rs
@@ -192,18 +192,25 @@ impl<'ws> Viewport<'ws> {
             .flex(Flex::Start))
     }
 
-    fn compute_cell_style<'widget>(&self, ri: usize, ci: usize, mut cell: Cell<'widget>) -> Cell<'widget> {
-        let style = self.book.get_cell_style(self.book.current_sheet, &Address { row: ri, col: ci, });
-        let bg_color = map_color(style.as_ref().map(|s| s.fill.bg_color.as_ref()).flatten(), Color::Rgb(35, 33, 54));
-        let fg_color = map_color(style.as_ref().map(|s| s.fill.fg_color.as_ref()).flatten(), Color::White);
-        if let Some((start, end)) =
-            &self.range_selection.map_or(None, |r| r.get_range())
-        {
-            if ri >= start.row
-                && ri <= end.row
-                && ci >= start.col
-                && ci <= end.col
-            {
+    fn compute_cell_style<'widget>(
+        &self,
+        ri: usize,
+        ci: usize,
+        mut cell: Cell<'widget>,
+    ) -> Cell<'widget> {
+        let style = self
+            .book
+            .get_cell_style(self.book.current_sheet, &Address { row: ri, col: ci });
+        let bg_color = map_color(
+            style.as_ref().map(|s| s.fill.bg_color.as_ref()).flatten(),
+            Color::Rgb(35, 33, 54),
+        );
+        let fg_color = map_color(
+            style.as_ref().map(|s| s.fill.fg_color.as_ref()).flatten(),
+            Color::White,
+        );
+        if let Some((start, end)) = &self.range_selection.map_or(None, |r| r.get_range()) {
+            if ri >= start.row && ri <= end.row && ci >= start.col && ci <= end.col {
                 // This is a selected range
                 cell = cell.fg(Color::Black).bg(Color::LightBlue)
             }
@@ -220,40 +227,50 @@ impl<'ws> Viewport<'ws> {
 }
 
 pub(crate) fn map_color(color: Option<&String>, otherwise: Color) -> Color {
-    color.map(|s| match s.to_lowercase().as_str() {
-        "red" => Color::Red,
-        "blue" => Color::Blue,
-        "green" => Color::Green,
-        "magenta" => Color::Magenta,
-        "cyan" => Color::Cyan,
-        "white" => Color::White,
-        "yellow" => Color::Yellow,
-        "black" => Color::Black,
-        "gray" | "grey" => Color::Gray,
-        "lightred" => Color::LightRed,
-        "lightblue" => Color::LightBlue,
-        "lightgreen" => Color::LightGreen,
-        "lightmagenta" => Color::LightMagenta,
-        "lightcyan" => Color::LightCyan,
-        "lightyellow" => Color::LightYellow,
-        "darkgrey" | "darkgray" => Color::DarkGray,
-        candidate => {
-            // TODO(jeremy): Should we support more syntaxes than hex string?
-            // hsl(...) ??
-            // rgb(...) ??
-            if candidate.starts_with("#") {
-                if let Ok(rgb) = colorsys::Rgb::from_hex_str(candidate) {
-                    // Note that the colorsys rgb model clamps the f64 values to no more 
-                    // than 255.0 so the below casts are safe.
-                    Color::Rgb(rgb.red() as u8, rgb.green() as u8, rgb.blue() as u8)
+    color
+        .map(|s| match s.to_lowercase().as_str() {
+            "red" => Color::Red,
+            "blue" => Color::Blue,
+            "green" => Color::Green,
+            "magenta" => Color::Magenta,
+            "cyan" => Color::Cyan,
+            "white" => Color::White,
+            "yellow" => Color::Yellow,
+            "black" => Color::Black,
+            "gray" | "grey" => Color::Gray,
+            "lightred" => Color::LightRed,
+            "lightblue" => Color::LightBlue,
+            "lightgreen" => Color::LightGreen,
+            "lightmagenta" => Color::LightMagenta,
+            "lightcyan" => Color::LightCyan,
+            "lightyellow" => Color::LightYellow,
+            "darkgrey" | "darkgray" => Color::DarkGray,
+            candidate => {
+                // TODO(jeremy): Should we support more syntaxes than hex string?
+                // hsl(...) ??
+                // rgb(...) ??
+                if candidate.starts_with("#") {
+                    if let Ok(rgb) = colorsys::Rgb::from_hex_str(candidate) {
+                        // Note that the colorsys rgb model clamps the f64 values to no more
+                        // than 255.0 so the below casts are safe.
+                        Color::Rgb(rgb.red() as u8, rgb.green() as u8, rgb.blue() as u8)
+                    } else {
+                        otherwise
+                    }
+                } else if candidate.starts_with("rgb(") {
+                    if let Ok(rgb) = <colorsys::Rgb as std::str::FromStr>::from_str(candidate) {
+                        // Note that the colorsys rgb model clamps the f64 values to no more
+                        // than 255.0 so the below casts are safe.
+                        Color::Rgb(rgb.red() as u8, rgb.green() as u8, rgb.blue() as u8)
+                    } else {
+                        otherwise
+                    }
                 } else {
                     otherwise
                 }
-            } else {
-                otherwise
             }
-        }
-    }).unwrap_or(otherwise)
+        })
+        .unwrap_or(otherwise)
 }
 
 impl<'ws> StatefulWidget for Viewport<'ws> {