diff --git a/README.md b/README.md
index 71c077f1..3db5b9a0 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
A simple datasheet component for editing tabular data.
-
+
#### Features
- Data editing
@@ -10,10 +10,10 @@ A simple datasheet component for editing tabular data.
- Add custom editors for any data type
- Conditional formatting
- Data validation
-- Build datasheet from an object definition
+- Formula
- Keyboard navigation
- Copy and paste from tabulated data
-- Virtualization via Blazor Virtualization - handles many cells at once.
+- Virtualization - _handles_ many cells at once in both rows & cols.
Demo: https://anmcgrath.github.io/BlazorDatasheet/
@@ -43,3 +43,87 @@ The following code displays an empty 3 x 3 data grid.
```
The default editor is the text editor, but can be changed by defining the Type property of each cell.
+
+### Setting & getting cell values
+
+Cell values can be set in a few ways:
+
+```csharp
+sheet.Cells[0, 0].Value = "Test"
+sheet.Range("A1").Value = "Test";
+sheet.Cells.SetValue(0, 0, "Test");
+sheet.Commands.ExecuteCommand(new SetCellValueCommand(0, 0, "Test"));
+```
+
+In this example, the first two methods set the value but cannot be undone. The last two methods can be undone.
+
+### Formula
+
+Formula can be applied to cells. When the cells or ranges that the formula cells reference change, the cell value is re-calculated.
+
+Currently, the whole sheet is calculated if any referenced cell or range changes.
+
+```csharp
+sheet.Cells[0, 0].Formula = "=10+A2"
+```
+
+### Formatting
+
+Cell formats can be set in the following ways:
+
+```csharp
+sheet.Range("A1:A2").Format = new CellFormat() { BackgroundColor = "red" };
+sheet.Commands.ExecuteCommand(
+ new SetFormatCommand(new RowRegion(10, 12), new CellFormat() { ForegroundColor = "blue" }));
+sheet.SetFormat(sheet.Range(new ColumnRegion(5)), new CellFormat() { FontWeight = "bold" });
+sheet.Cells[0, 0].Format = new CellFormat() { TextAlign = "center" };
+```
+
+When a cell format is set, it will be merged into any existing cell formats in the region that it is applied to. Any non-null format paremeters will be merged:
+
+```csharp
+sheet.Range("A1").Format = new CellFormat() { BackgroundColor = "red" };
+sheet.Range("A1:A2").Format = new CellFormat() { ForegroundColor = "blue" };
+var format = sheet.Cells[0, 0].Format; // backroundColor = "red", foreground = "blue"
+var format2 = sheet.Cells[1, 0].Format; // foreground = "blue"
+```
+
+### Cell types
+The cell type specifies which renderer and editor are used for the cell.
+
+```csharp
+sheet.Range("A1:B5").Type = "boolean"; // renders a checkbox
+```
+
+Custom editors and renderers can be defined. See the examples for more information.
+
+### Validation
+Data validation can be set on cells/ranges. There are two modes of validation: strict and non-strict. When a validator is strict, the cell value will not be set by the editor if it fails validation.
+
+If validation is not strict, the value can be set during editing but will show a validation error when rendered.
+
+Although a strict validation may be set on a cell, the value can be changed programmatically, but it will display as a validation error.
+
+```csharp
+sheet.Validators.Add(new ColumnRegion(0), new NumberValidator(isStrict: true));
+```
+
+### Regions and ranges
+
+A region is a geometric construct, for example:
+
+```csharp
+var region = new Region(0, 5, 0, 5); // r0 to r5, c0 to c5
+var cellRegion = new Region(0, 0); // cell A1
+var colRegion = new ColumnRegion(0, 4); // col region spanning A to D
+var rowRegion = new RowRegion(0, 3); // row region spanning 1 to 4
+```
+
+A range is a collection of regions that also knows about the sheet. Ranges can be used to set certain parts of the sheet.
+
+```csharp
+var range = sheet.Range("A1:C5, B2:B7");
+var range = sheet.Range(new ColumnRegion(0));
+var range = sheet.Range(regions);
+var range = sheet.Range(0, 0, 4, 5);
+```
diff --git a/src/.run/dotnet watch run.run.xml b/src/.run/dotnet watch run.run.xml
index 03e3ef1b..39e17391 100644
--- a/src/.run/dotnet watch run.run.xml
+++ b/src/.run/dotnet watch run.run.xml
@@ -1,8 +1,8 @@
-
+
-
+
diff --git a/src/BlazorDatasheet.Core/BlazorDatasheet.Core.csproj b/src/BlazorDatasheet.Core/BlazorDatasheet.Core.csproj
new file mode 100644
index 00000000..e1e4ce00
--- /dev/null
+++ b/src/BlazorDatasheet.Core/BlazorDatasheet.Core.csproj
@@ -0,0 +1,15 @@
+
+
+
+ net7.0
+ enable
+ enable
+
+
+
+
+
+
+
+
+
diff --git a/src/BlazorDatasheet.Core/Color/ColorConverter.cs b/src/BlazorDatasheet.Core/Color/ColorConverter.cs
new file mode 100644
index 00000000..54e1f4fd
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Color/ColorConverter.cs
@@ -0,0 +1,116 @@
+using BlazorDatasheet.DataStructures.Util;
+
+namespace BlazorDatasheet.Core.Color;
+
+public class ColorConverter
+{
+ public static System.Drawing.Color HSVToRGB(double H, double S, double V)
+ {
+ double r = 0, g = 0, b = 0;
+
+ if (S == 0)
+ {
+ r = V;
+ g = V;
+ b = V;
+ }
+ else
+ {
+ int i;
+ double f, p, q, t;
+
+ if (H == 360)
+ H = 0;
+ else
+ H = H / 60;
+
+ i = (int)Math.Truncate(H);
+ f = H - i;
+
+ p = V * (1.0 - S);
+ q = V * (1.0 - (S * f));
+ t = V * (1.0 - (S * (1.0 - f)));
+
+ switch (i)
+ {
+ case 0:
+ r = V;
+ g = t;
+ b = p;
+ break;
+
+ case 1:
+ r = q;
+ g = V;
+ b = p;
+ break;
+
+ case 2:
+ r = p;
+ g = V;
+ b = t;
+ break;
+
+ case 3:
+ r = p;
+ g = q;
+ b = V;
+ break;
+
+ case 4:
+ r = t;
+ g = p;
+ b = V;
+ break;
+
+ default:
+ r = V;
+ g = p;
+ b = q;
+ break;
+ }
+ }
+
+ return System.Drawing.Color.FromArgb((byte)(r * 255), (byte)(g * 255), (byte)(b * 255));
+ }
+
+ public static (double h, double s, double v) RGBToHSV(System.Drawing.Color color)
+ {
+ float cmax = Math.Max(color.R, Math.Max(color.G, color.B));
+ float cmin = Math.Min(color.R, Math.Min(color.G, color.B));
+ float delta = cmax - cmin;
+
+ float hue = 0;
+ float saturation = 0;
+
+ if (cmax == color.R)
+ {
+ hue = 60 * (((color.G - color.B) / delta) % 6);
+ }
+ else if (cmax == color.G)
+ {
+ hue = 60 * ((color.B - color.R) / delta + 2);
+ }
+ else if (cmax == color.B)
+ {
+ hue = 60 * ((color.R - color.G) / delta + 4);
+ }
+
+ if (cmax > 0)
+ {
+ saturation = delta / cmax;
+ }
+
+ return (hue, saturation, cmax);
+ }
+
+
+ public static (double h, double s, double v) HsvInterp((double h, double s, double v) c0, (double h, double s,
+ double v) c1, double t)
+ {
+ double h = ((1 - t) * c0.h + t * c1.h) % 360;
+ double s = SheetMath.ClampDouble(0, 1, ((1 - t) * c0.s + t * c1.s));
+ double v = SheetMath.ClampDouble(0, 1, ((1 - t) * c0.v + t * c1.v));
+ return (h, s, v);
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Commands/ClearCellsCommand.cs b/src/BlazorDatasheet.Core/Commands/ClearCellsCommand.cs
new file mode 100644
index 00000000..65c12588
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Commands/ClearCellsCommand.cs
@@ -0,0 +1,31 @@
+using BlazorDatasheet.Core.Data;
+using BlazorDatasheet.Core.Data.Cells;
+using BlazorDatasheet.Formula.Core;
+
+namespace BlazorDatasheet.Core.Commands;
+
+///
+/// Clears cell values in the given ranges
+///
+public class ClearCellsCommand : IUndoableCommand
+{
+ private readonly SheetRange _range;
+ private CellStoreRestoreData _restoreData;
+
+ public ClearCellsCommand(SheetRange range)
+ {
+ _range = range.Clone();
+ }
+
+ public bool Execute(Sheet sheet)
+ {
+ _restoreData = sheet.Cells.ClearCellsImpl(_range.Regions);
+ return true;
+ }
+
+ public bool Undo(Sheet sheet)
+ {
+ sheet.Cells.Restore(_restoreData);
+ return true;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet/Commands/CommandGroup.cs b/src/BlazorDatasheet.Core/Commands/CommandGroup.cs
similarity index 52%
rename from src/BlazorDatasheet/Commands/CommandGroup.cs
rename to src/BlazorDatasheet.Core/Commands/CommandGroup.cs
index fc210117..e1feb6b4 100644
--- a/src/BlazorDatasheet/Commands/CommandGroup.cs
+++ b/src/BlazorDatasheet.Core/Commands/CommandGroup.cs
@@ -1,26 +1,32 @@
-using BlazorDatasheet.Data;
+using BlazorDatasheet.Core.Data;
-namespace BlazorDatasheet.Commands;
+namespace BlazorDatasheet.Core.Commands;
public class CommandGroup : IUndoableCommand
{
- private IEnumerable _commands;
- private List _successfulCommands;
+ private readonly List _commands;
+ private readonly List _successfulCommands;
///
/// Runs a series of commands sequentially, but stops if any fails.
///
///
- public CommandGroup(params IUndoableCommand[] commands)
+ public CommandGroup(params ICommand[] commands)
{
- _commands = commands;
- _successfulCommands = new List();
+ _commands = commands.ToList();
+ _successfulCommands = new List();
+ }
+
+ public void AddCommand(ICommand command)
+ {
+ _commands.Add(command);
}
public bool Execute(Sheet sheet)
{
_successfulCommands.Clear();
+ sheet.BatchUpdates();
foreach (var command in _commands)
{
var run = command.Execute(sheet);
@@ -34,16 +40,22 @@ public bool Execute(Sheet sheet)
_successfulCommands.Add(command);
}
+ sheet.EndBatchUpdates();
+
return true;
}
public bool Undo(Sheet sheet)
{
var undo = true;
- foreach (var command in _successfulCommands)
+ var undoCommands = _successfulCommands.Where(cmd => cmd is IUndoableCommand).Cast().ToList();
+ undoCommands.Reverse();
+ sheet.BatchUpdates();
+ foreach (var command in undoCommands)
{
undo &= command.Undo(sheet);
}
+ sheet.EndBatchUpdates();
return undo;
}
diff --git a/src/BlazorDatasheet.Core/Commands/CommandManager.cs b/src/BlazorDatasheet.Core/Commands/CommandManager.cs
new file mode 100644
index 00000000..36fa0cea
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Commands/CommandManager.cs
@@ -0,0 +1,205 @@
+using BlazorDatasheet.Core.Data;
+using BlazorDatasheet.Core.Selecting;
+using BlazorDatasheet.Core.Util;
+
+namespace BlazorDatasheet.Core.Commands;
+
+public class CommandManager
+{
+ private readonly MaxStack _history;
+ private readonly MaxStack _redos;
+ private Sheet _sheet;
+ private CommandGroup? _currentCommandGroup;
+
+ ///
+ /// Whether the commands executed are being collected in a group.
+ ///
+ private bool _isCollectingCommands;
+
+ ///
+ /// If history is paused, commands are no longer added to the undo/redo stack.
+ ///
+ public bool HistoryPaused { get; private set; }
+
+ public CommandManager(Sheet sheet, int maxHistorySize = 50)
+ {
+ _sheet = sheet;
+ _history = new MaxStack(maxHistorySize);
+ _redos = new MaxStack(maxHistorySize);
+ }
+
+ ///
+ /// Executes a command and, if it is an undoable command, adds it to the undo stack.
+ ///
+ ///
+ ///
+ public bool ExecuteCommand(ICommand command)
+ {
+ if (_isCollectingCommands)
+ {
+ _currentCommandGroup!.AddCommand(command);
+ return true;
+ }
+
+ var result = command.Execute(_sheet);
+ if (result)
+ {
+ if (!HistoryPaused && command is IUndoableCommand undoCommand)
+ {
+ _history.Push(new UndoCommandData()
+ {
+ Command = undoCommand,
+ Selection = _sheet.Selection.Clone()
+ });
+ }
+ }
+
+ // Clear the redo stack because otherwise we will be redoing changes to the sheet with a changed
+ // model from the original time the commands were run.
+ _redos.Clear();
+
+ return result;
+ }
+
+ internal void SetSheet(Sheet sheet)
+ {
+ _sheet = sheet;
+ }
+
+ ///
+ /// Returns all the undo commands in the undo stack
+ ///
+ ///
+ public IEnumerable GetUndoCommands()
+ {
+ return _history.GetAllItems().Select(x => x.Command);
+ }
+
+ ///
+ /// Returns all the redo commands in the redo stack.
+ ///
+ ///
+ public IEnumerable GetRedoCommands()
+ {
+ return _redos.GetAllItems();
+ }
+
+ ///
+ /// Executes the undo function of the last undo-able command run.
+ ///
+ ///
+ public bool Undo()
+ {
+ if (_isCollectingCommands)
+ return false;
+
+ if (_history.Peek() == null)
+ return false;
+
+ var cmd = _history.Pop()!;
+ var result = cmd.Command.Undo(_sheet);
+ if (cmd.Selection != null)
+ _sheet.Selection.Set(cmd.Selection);
+
+ if (!HistoryPaused && result)
+ {
+ _redos.Push(cmd.Command);
+ }
+
+ return result;
+ }
+
+ ///
+ /// Execute the last command that was un-done.
+ ///
+ ///
+ public bool Redo()
+ {
+ if (_isCollectingCommands)
+ return false;
+
+ if (_redos.Peek() == null)
+ return false;
+
+ var cmd = _redos.Pop()!;
+ var result = cmd.Execute(_sheet);
+
+ if (result)
+ {
+ if (!HistoryPaused && cmd is IUndoableCommand undoCommand)
+ {
+ _history.Push(new UndoCommandData()
+ {
+ Command = undoCommand,
+ Selection = _sheet.Selection.Clone()
+ });
+ }
+ }
+
+ return result;
+ }
+
+ ///
+ /// Removes all commands from the history, clearing the undo/redo functionality for those commands.
+ ///
+ public void ClearHistory()
+ {
+ _history.Clear();
+ }
+
+ ///
+ /// Stop commands to be added to the undo/redo stack.
+ ///
+ public void PauseHistory()
+ {
+ HistoryPaused = true;
+ }
+
+ ///
+ /// Allow commands to be added to the undo/redo stack.
+ ///
+ public void ResumeHistory()
+ {
+ HistoryPaused = false;
+ }
+
+ ///
+ /// Starts collecting commands in a group. When collecting is finished, via EndCommandGroup()
+ /// the commands are executed. When the commands are then undone/redone, they are undone/redone together.
+ ///
+ public void BeginCommandGroup()
+ {
+ _isCollectingCommands = true;
+ _currentCommandGroup = new CommandGroup();
+ }
+
+ ///
+ /// Finishes collecting commands in a group and executes the commands in the group.
+ ///
+ public bool EndCommandGroup()
+ {
+ _isCollectingCommands = false;
+ if (_currentCommandGroup != null)
+ {
+ var res = this.ExecuteCommand(_currentCommandGroup);
+ _currentCommandGroup = null;
+ return res;
+ }
+
+ _currentCommandGroup = null;
+ return false;
+ }
+}
+
+internal class UndoCommandData
+{
+ ///
+ /// The command to undo.
+ ///
+ public IUndoableCommand Command { get; init; }
+
+ ///
+ /// The selected range at the time the command was run.
+ ///
+ public SheetRange? Selection { get; init; }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet/Commands/ICommand.cs b/src/BlazorDatasheet.Core/Commands/ICommand.cs
similarity index 65%
rename from src/BlazorDatasheet/Commands/ICommand.cs
rename to src/BlazorDatasheet.Core/Commands/ICommand.cs
index fe839c82..2533ad44 100644
--- a/src/BlazorDatasheet/Commands/ICommand.cs
+++ b/src/BlazorDatasheet.Core/Commands/ICommand.cs
@@ -1,6 +1,6 @@
-using BlazorDatasheet.Data;
+using BlazorDatasheet.Core.Data;
-namespace BlazorDatasheet.Commands;
+namespace BlazorDatasheet.Core.Commands;
///
/// A command that can be executed on the sheet
diff --git a/src/BlazorDatasheet/Commands/IUndoableCommand.cs b/src/BlazorDatasheet.Core/Commands/IUndoableCommand.cs
similarity index 78%
rename from src/BlazorDatasheet/Commands/IUndoableCommand.cs
rename to src/BlazorDatasheet.Core/Commands/IUndoableCommand.cs
index 6f42aae4..1e43ea4e 100644
--- a/src/BlazorDatasheet/Commands/IUndoableCommand.cs
+++ b/src/BlazorDatasheet.Core/Commands/IUndoableCommand.cs
@@ -1,6 +1,6 @@
-using BlazorDatasheet.Data;
+using BlazorDatasheet.Core.Data;
-namespace BlazorDatasheet.Commands;
+namespace BlazorDatasheet.Core.Commands;
///
/// A command that can be un-done/re-run
diff --git a/src/BlazorDatasheet.Core/Commands/InsertColAtCommand.cs b/src/BlazorDatasheet.Core/Commands/InsertColAtCommand.cs
new file mode 100644
index 00000000..28704c45
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Commands/InsertColAtCommand.cs
@@ -0,0 +1,40 @@
+using BlazorDatasheet.Core.Data;
+
+namespace BlazorDatasheet.Core.Commands;
+
+///
+/// Command for inserting a column in to the sheet
+///
+public class InsertColAtCommand : IUndoableCommand
+{
+ private readonly int _colIndex;
+ private readonly int _nCols;
+
+ ///
+ /// Command for inserting a column into the sheet.
+ ///
+ /// The index that the column will be inserted at.
+ public InsertColAtCommand(int colIndex, int nCols = 1)
+ {
+ _colIndex = colIndex;
+ _nCols = nCols;
+ }
+
+ public bool Execute(Sheet sheet)
+ {
+ sheet.Validators.Store.InsertCols(_colIndex, _nCols);
+ sheet.Cells.InsertColAt(_colIndex, _nCols);
+ sheet.InsertColAtImpl(_colIndex, _nCols);
+ sheet.Columns.InsertImpl(_colIndex, _nCols);
+ return true;
+ }
+
+ public bool Undo(Sheet sheet)
+ {
+ sheet.Validators.Store.RemoveCols(_colIndex, _colIndex + _nCols - 1);
+ sheet.RemoveColImpl(_colIndex, _nCols);
+ sheet.Cells.RemoveColAt(_colIndex, _nCols);
+ sheet.Columns.RemoveColumnsImpl(_colIndex, _colIndex + _nCols - 1);
+ return true;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Commands/InsertRowsAtCommand.cs b/src/BlazorDatasheet.Core/Commands/InsertRowsAtCommand.cs
new file mode 100644
index 00000000..a8f9ccbd
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Commands/InsertRowsAtCommand.cs
@@ -0,0 +1,41 @@
+using BlazorDatasheet.Core.Data;
+
+namespace BlazorDatasheet.Core.Commands;
+
+///
+/// Command for inserting a row into the sheet.
+///
+internal class InsertRowsAtCommand : IUndoableCommand
+{
+ private readonly int _index;
+ private readonly int _nRows;
+
+ ///
+ /// Command for inserting a row into the sheet.
+ ///
+ /// The index that the row will be inserted at.
+ /// The number of rows to insert
+ public InsertRowsAtCommand(int index, int nRows = 1)
+ {
+ _index = index;
+ _nRows = nRows;
+ }
+
+ public bool Execute(Sheet sheet)
+ {
+ sheet.Validators.Store.InsertRows(_index, _nRows);
+ sheet.Cells.InsertRowAt(_index, _nRows);
+ sheet.InsertRowAtImpl(_index, _nRows);
+ sheet.Rows.InsertImpl(_index, _nRows);
+ return true;
+ }
+
+ public bool Undo(Sheet sheet)
+ {
+ sheet.Validators.Store.RemoveRows(_index, _index + _nRows - 1);
+ sheet.Cells.RemoveRowAt(_index, _nRows);
+ sheet.RemoveRowAtImpl(_index, _nRows);
+ sheet.Rows.RemoveRowsImpl(_index, _index + _nRows - 1);
+ return true;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet/Commands/MergeCellsCommand.cs b/src/BlazorDatasheet.Core/Commands/MergeCellsCommand.cs
similarity index 57%
rename from src/BlazorDatasheet/Commands/MergeCellsCommand.cs
rename to src/BlazorDatasheet.Core/Commands/MergeCellsCommand.cs
index ae19edce..8ff37f56 100644
--- a/src/BlazorDatasheet/Commands/MergeCellsCommand.cs
+++ b/src/BlazorDatasheet.Core/Commands/MergeCellsCommand.cs
@@ -1,21 +1,23 @@
-using BlazorDatasheet.Data;
-using BlazorDatasheet.Util;
+using BlazorDatasheet.Core.Data;
+using BlazorDatasheet.Core.Data.Cells;
+using BlazorDatasheet.DataStructures.Geometry;
+using BlazorDatasheet.Formula.Core;
-namespace BlazorDatasheet.Commands;
+namespace BlazorDatasheet.Core.Commands;
public class MergeCellsCommand : IUndoableCommand
{
- private readonly BRange _range;
+ private readonly SheetRange _range;
private readonly List _overridenMergedRegions = new();
private readonly List _mergesPerformed = new();
- private readonly List _changes = new();
+ private CellStoreRestoreData _restoreData;
///
/// Command that merges the cells in the range give.
/// Note that the value in the top LHS will be kept, while other cell values will be cleared.
///
/// The range in which to merge.
- public MergeCellsCommand(BRange range)
+ public MergeCellsCommand(SheetRange range)
{
_range = range.Clone();
}
@@ -24,57 +26,52 @@ public MergeCellsCommand(BRange range)
public bool Execute(Sheet sheet)
{
_overridenMergedRegions.Clear();
- _changes.Clear();
_mergesPerformed.Clear();
foreach (var region in _range.Regions)
{
- var envelope = region.ToEnvelope();
// Determine if there are any merged cells in the region
// We can only merge over merged cells if we entirely overlap them
- var existingMerges = sheet.MergedCells.Search(envelope);
- if (!existingMerges.All(x => region.Contains(x.Region)))
+ var existingMerges = sheet.Cells.GetMerges(region).ToList();
+ if (!existingMerges.All(x => region.Contains(x)))
continue;
// Clear all the cells that are not the top-left posn of merge and store their values for undo
- var cellsToClear = region
+ var regionsToClear = region
.Break(region.TopLeft)
- .SelectMany(sheet.GetNonEmptyCellPositions)
.ToList();
- _changes.AddRange(cellsToClear.Select(x => getValueChangeOnClear(x.row, x.col, sheet)));
- sheet.ClearCellsImpl(cellsToClear);
+ _restoreData = sheet.Cells.ClearCellsImpl(regionsToClear);
// Store the merges that we will have to re-instate on undo
// And remove any merges that are contained in the region
- _overridenMergedRegions.AddRange(existingMerges.Select(x => x.Region));
- sheet.UnMergeCellsImpl(new BRange(sheet, existingMerges.Select(x => x.Region)));
+ _overridenMergedRegions.AddRange(existingMerges);
+ sheet.Cells.UnMergeCellsImpl(new SheetRange(sheet, existingMerges));
// Store the merge that we are doing and perform the actual merge
_mergesPerformed.Add(region);
- sheet.MergeCellsImpl(region);
+ sheet.Cells.MergeImpl(region);
}
return true;
}
- private CellChange getValueChangeOnClear(int row, int col, Sheet sheet)
+ private CellValueChange getValueChangeOnClear(int row, int col, Sheet sheet)
{
- return new CellChange(row, col, sheet.GetValue(row, col));
+ return new CellValueChange(row, col, sheet.Cells.GetValue(row, col));
}
public bool Undo(Sheet sheet)
{
// Undo the merge we performed
foreach (var merge in _mergesPerformed)
- sheet.UnMergeCellsImpl(merge);
+ sheet.Cells.UnMergeCellsImpl(merge);
// Restore all the merges we removed
foreach (var removedMerge in _overridenMergedRegions)
- sheet.MergeCellsImpl(removedMerge);
-
- sheet.Selection.Set(_range);
+ sheet.Cells.MergeImpl(removedMerge);
+
// Restore all the cell values that were lost when merging
- sheet.SetCellValuesImpl(_changes);
+ sheet.Cells.Restore(_restoreData);
return true;
}
diff --git a/src/BlazorDatasheet.Core/Commands/RemoveColumnCommand.cs b/src/BlazorDatasheet.Core/Commands/RemoveColumnCommand.cs
new file mode 100644
index 00000000..0f97fe21
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Commands/RemoveColumnCommand.cs
@@ -0,0 +1,74 @@
+using BlazorDatasheet.Core.Data;
+using BlazorDatasheet.Core.Data.Cells;
+using BlazorDatasheet.Core.Events;
+using BlazorDatasheet.Core.Formats;
+using BlazorDatasheet.DataStructures.Geometry;
+using BlazorDatasheet.DataStructures.Intervals;
+using BlazorDatasheet.DataStructures.Store;
+
+namespace BlazorDatasheet.Core.Commands;
+
+public class RemoveColumnCommand : IUndoableCommand
+{
+ private int _columnIndex;
+ private readonly int _nCols;
+
+ private RegionRestoreData _mergeRestoreData;
+ private RegionRestoreData _validatorRestoreData;
+ private CellStoreRestoreData _cellStoreRestoreData;
+ private List> _colFormatRestoreData;
+ private int _nColsRemoved;
+ private ColumnInfoRestoreData _columnInfoRestoreData;
+
+ ///
+ /// Command for removing a column at the index given.
+ ///
+ /// The column to remove.
+ public RemoveColumnCommand(int columnIndex, int nCols)
+ {
+ _columnIndex = columnIndex;
+ _nCols = nCols;
+ }
+
+ public bool Execute(Sheet sheet)
+ {
+ if (_columnIndex >= sheet.NumCols)
+ return false;
+ if (_nCols <= 0)
+ return false;
+ _nColsRemoved = Math.Min(sheet.NumCols - _columnIndex + 1, _nCols);
+
+ if (_nColsRemoved == 0)
+ return false;
+
+ _cellStoreRestoreData = sheet.Cells.RemoveColAt(_columnIndex, _nColsRemoved);
+ _columnInfoRestoreData = sheet.Columns.RemoveColumnsImpl(_columnIndex, _columnIndex + _nColsRemoved - 1);
+ _validatorRestoreData = sheet.Validators.Store.RemoveCols(_columnIndex, _columnIndex + _nColsRemoved - 1);
+ return sheet.RemoveColImpl(_columnIndex, _nColsRemoved);
+ }
+
+ public bool Undo(Sheet sheet)
+ {
+ UndoValidation(sheet);
+
+ // Insert column back in and set all the values that we removed
+ sheet.InsertColAtImpl(_columnIndex, _nColsRemoved);
+
+ sheet.Cells.InsertColAt(_columnIndex, _nColsRemoved, false);
+ sheet.Cells.Restore(_cellStoreRestoreData);
+
+ sheet.Columns.InsertImpl(_columnIndex, _nColsRemoved);
+ sheet.Columns.Restore(_columnInfoRestoreData);
+
+ sheet.MarkDirty(new ColumnRegion(_columnIndex, sheet.NumCols));
+
+ return true;
+ }
+
+
+ private void UndoValidation(Sheet sheet)
+ {
+ sheet.Validators.Store.InsertCols(_columnIndex, _nColsRemoved, false);
+ sheet.Validators.Store.Restore(_validatorRestoreData);
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Commands/RemoveRowsCommand.cs b/src/BlazorDatasheet.Core/Commands/RemoveRowsCommand.cs
new file mode 100644
index 00000000..7c3fe2ed
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Commands/RemoveRowsCommand.cs
@@ -0,0 +1,66 @@
+using BlazorDatasheet.Core.Data;
+using BlazorDatasheet.Core.Data.Cells;
+using BlazorDatasheet.Core.Events;
+using BlazorDatasheet.Core.Formats;
+using BlazorDatasheet.DataStructures.Geometry;
+using BlazorDatasheet.DataStructures.Intervals;
+using BlazorDatasheet.DataStructures.Store;
+
+namespace BlazorDatasheet.Core.Commands;
+
+public class RemoveRowsCommand : IUndoableCommand
+{
+ private readonly int _rowIndex;
+ private readonly int _nRows;
+
+ private List _removedCellFormats;
+ private RegionRestoreData _mergeRestoreData;
+ private RegionRestoreData _validatorRestoreData;
+ private RowInfoStoreRestoreData _rowInfoStoreRestore;
+ private CellStoreRestoreData _cellStoreRestoreData;
+
+ // The actual number of rows removed (takes into account num of rows in sheet)
+ private int _nRowsRemoved;
+
+ ///
+ /// Command to remove the row at the index given.
+ ///
+ /// The row to remove.
+ /// The number of rows to remove
+ public RemoveRowsCommand(int rowIndex, int nRows = 1)
+ {
+ _rowIndex = rowIndex;
+ _nRows = nRows;
+ }
+
+ public bool Execute(Sheet sheet)
+ {
+ if (_rowIndex >= sheet.NumRows)
+ return false;
+ if (_nRows <= 0)
+ return false;
+ _nRowsRemoved = Math.Min(sheet.NumRows - _rowIndex + 1, _nRows);
+
+ _cellStoreRestoreData = sheet.Cells.RemoveRowAt(_rowIndex, _nRowsRemoved);
+ _rowInfoStoreRestore = sheet.Rows.RemoveRowsImpl(_rowIndex, _rowIndex + _nRowsRemoved - 1);
+ _validatorRestoreData = sheet.Validators.Store.RemoveRows(_rowIndex, _rowIndex + _nRowsRemoved - 1);
+ return sheet.RemoveRowAtImpl(_rowIndex, _nRowsRemoved);
+ }
+
+ public bool Undo(Sheet sheet)
+ {
+ sheet.Validators.Store.InsertRows(_rowIndex, _nRowsRemoved, false);
+ sheet.Validators.Store.Restore(_validatorRestoreData);
+
+ sheet.Cells.InsertRowAt(_rowIndex, _nRows, false);
+ sheet.Cells.Restore(_cellStoreRestoreData);
+
+ sheet.Rows.InsertImpl(_rowIndex, _nRowsRemoved);
+ sheet.Rows.Restore(_rowInfoStoreRestore);
+
+ sheet.InsertRowAtImpl(_rowIndex);
+
+ sheet.MarkDirty(new RowRegion(_rowIndex, sheet.NumRows));
+ return true;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Commands/SetCellValueCommand.cs b/src/BlazorDatasheet.Core/Commands/SetCellValueCommand.cs
new file mode 100644
index 00000000..bd0bbd82
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Commands/SetCellValueCommand.cs
@@ -0,0 +1,32 @@
+using BlazorDatasheet.Core.Data;
+using BlazorDatasheet.Core.Data.Cells;
+using BlazorDatasheet.Formula.Core;
+
+namespace BlazorDatasheet.Core.Commands;
+
+public class SetCellValueCommand : IUndoableCommand
+{
+ private readonly int _row;
+ private readonly int _col;
+ private readonly object? _value;
+ private CellStoreRestoreData _restoreData;
+
+ public SetCellValueCommand(int row, int col, object? value)
+ {
+ _row = row;
+ _col = col;
+ _value = value;
+ }
+
+ public bool Execute(Sheet sheet)
+ {
+ _restoreData = sheet.Cells.SetValueImpl(_row, _col, _value);
+ return true;
+ }
+
+ public bool Undo(Sheet sheet)
+ {
+ sheet.Cells.Restore(_restoreData);
+ return true;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Commands/SetColumnHeadingsCommand.cs b/src/BlazorDatasheet.Core/Commands/SetColumnHeadingsCommand.cs
new file mode 100644
index 00000000..d40b07fc
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Commands/SetColumnHeadingsCommand.cs
@@ -0,0 +1,34 @@
+using BlazorDatasheet.Core.Data;
+
+namespace BlazorDatasheet.Core.Commands;
+
+public class SetColumnHeadingsCommand: IUndoableCommand
+{
+ private readonly int _colStart;
+ private readonly int _colEnd;
+ private readonly string _heading;
+ private List<(int start, int end, string heading)> _restoreData;
+
+ public SetColumnHeadingsCommand(int colStart, int colEnd, string heading)
+ {
+ _colStart = colStart;
+ _colEnd = colEnd;
+ _heading = heading;
+ }
+
+ public bool Execute(Sheet sheet)
+ {
+ _restoreData = sheet.Columns.SetColumnHeadingsImpl(_colStart, _colEnd, _heading);
+ return true;
+ }
+
+ public bool Undo(Sheet sheet)
+ {
+ foreach (var heading in _restoreData)
+ {
+ sheet.Columns.SetColumnHeadingsImpl(heading.start, heading.end, heading.heading);
+ }
+
+ return true;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Commands/SetColumnWidthCommand.cs b/src/BlazorDatasheet.Core/Commands/SetColumnWidthCommand.cs
new file mode 100644
index 00000000..b5f9dd86
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Commands/SetColumnWidthCommand.cs
@@ -0,0 +1,40 @@
+using BlazorDatasheet.Core.Data;
+
+namespace BlazorDatasheet.Core.Commands;
+
+public class SetColumnWidthCommand : IUndoableCommand
+{
+ private readonly int _colStart;
+ private readonly int _colEnd;
+ private readonly double _width;
+ private List<(int start, int end, double width)> _oldWidths;
+
+ ///
+ /// Command that changes the column width to the specified amount
+ ///
+ /// The index of the column to change.
+ /// The end of the range to change
+ /// The new width of the column, in pixels
+ public SetColumnWidthCommand(int colStart, int colEnd, double width)
+ {
+ _colStart = colStart;
+ _colEnd = colEnd;
+ _width = width;
+ }
+
+ public bool Execute(Sheet sheet)
+ {
+ _oldWidths = sheet.Columns.SetColumnWidthsImpl(_colStart, _colEnd, _width);
+ return true;
+ }
+
+ public bool Undo(Sheet sheet)
+ {
+ for (int i = 0; i < _oldWidths.Count; i++)
+ {
+ sheet.Columns.SetColumnWidthsImpl(_oldWidths[i].start, _oldWidths[i].end, _oldWidths[i].width);
+ }
+
+ return true;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Commands/SetFormatCommand.cs b/src/BlazorDatasheet.Core/Commands/SetFormatCommand.cs
new file mode 100644
index 00000000..f22aad72
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Commands/SetFormatCommand.cs
@@ -0,0 +1,64 @@
+using BlazorDatasheet.Core.Data;
+using BlazorDatasheet.Core.Data.Cells;
+using BlazorDatasheet.Core.Events;
+using BlazorDatasheet.Core.Formats;
+using BlazorDatasheet.DataStructures.Geometry;
+using BlazorDatasheet.DataStructures.Intervals;
+using BlazorDatasheet.DataStructures.Store;
+
+namespace BlazorDatasheet.Core.Commands;
+
+public class SetFormatCommand : IUndoableCommand
+{
+ private readonly CellFormat _cellFormat;
+ private readonly IRegion _region;
+
+ private RowColFormatRestoreData? _colFormatRestoreData;
+ private RowColFormatRestoreData? _rowFormatRestoreData;
+ private CellStoreRestoreData? _cellFormatRestoreData;
+
+ ///
+ /// Command to set the format of the range given. The cell format is merged into the existing format, so that
+ /// only properties that are specifically defined in cellFormat are changed.
+ ///
+ /// The range to set the format for. Can be a cell, column or row range.
+ /// The new cell format.
+ public SetFormatCommand(IRegion region, CellFormat cellFormat)
+ {
+ _cellFormat = cellFormat;
+ _region = region.Clone();
+ }
+
+ public bool Execute(Sheet sheet)
+ {
+ if (_region is ColumnRegion columnRegion)
+ _colFormatRestoreData = sheet.Columns.SetColumnFormatImpl(_cellFormat, columnRegion);
+ else if (_region is RowRegion rowRegion)
+ _rowFormatRestoreData = sheet.Rows.SetRowFormatImpl(_cellFormat, rowRegion);
+ else
+ _cellFormatRestoreData = sheet.Cells.MergeFormatImpl(_region, _cellFormat);
+ return true;
+ }
+
+ public bool Undo(Sheet sheet)
+ {
+ if (_colFormatRestoreData != null)
+ Restore(sheet, _colFormatRestoreData, sheet.Columns.ColFormats);
+ if (_rowFormatRestoreData != null)
+ Restore(sheet, _rowFormatRestoreData, sheet.Rows.RowFormats);
+ if (_cellFormatRestoreData != null)
+ sheet.Cells.Restore(_cellFormatRestoreData);
+
+ sheet.MarkDirty(_region);
+ return true;
+ }
+
+ private void Restore(Sheet sheet, RowColFormatRestoreData restoreData, MergeableIntervalStore store)
+ {
+ foreach (var added in restoreData.IntervalsAdded)
+ store.Clear(added);
+ store.AddRange(restoreData.IntervalsRemoved.Where(x => x.Data != null));
+ foreach (var cellRestore in restoreData.CellFormatRestoreData)
+ sheet.Cells.Restore(cellRestore);
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet/Commands/SetMetaDataCommand.cs b/src/BlazorDatasheet.Core/Commands/SetMetaDataCommand.cs
similarity index 66%
rename from src/BlazorDatasheet/Commands/SetMetaDataCommand.cs
rename to src/BlazorDatasheet.Core/Commands/SetMetaDataCommand.cs
index b5e2b22b..e88da67b 100644
--- a/src/BlazorDatasheet/Commands/SetMetaDataCommand.cs
+++ b/src/BlazorDatasheet.Core/Commands/SetMetaDataCommand.cs
@@ -1,6 +1,6 @@
-using BlazorDatasheet.Data;
+using BlazorDatasheet.Core.Data;
-namespace BlazorDatasheet.Commands;
+namespace BlazorDatasheet.Core.Commands;
public class SetMetaDataCommand : IUndoableCommand
{
@@ -20,14 +20,14 @@ public SetMetaDataCommand(int row, int col, string name, object? value)
public bool Execute(Sheet sheet)
{
- _oldValue = sheet.GetMetaData(_row, _col, _name);
- sheet.SetMetaDataImpl(_row, _col, _name, _value);
+ _oldValue = sheet.Cells.GetMetaData(_row, _col, _name);
+ sheet.Cells.SetMetaDataImpl(_row, _col, _name, _value);
return true;
}
public bool Undo(Sheet sheet)
{
- sheet.SetMetaDataImpl(_row, _col, _name, _oldValue);
+ sheet.Cells.SetMetaDataImpl(_row, _col, _name, _oldValue);
return true;
}
}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Commands/SetParsedFormulaCommand.cs b/src/BlazorDatasheet.Core/Commands/SetParsedFormulaCommand.cs
new file mode 100644
index 00000000..82acbf3d
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Commands/SetParsedFormulaCommand.cs
@@ -0,0 +1,33 @@
+using BlazorDatasheet.Core.Data;
+using BlazorDatasheet.Core.Data.Cells;
+using BlazorDatasheet.Formula.Core;
+
+namespace BlazorDatasheet.Core.Commands;
+
+internal class SetParsedFormulaCommand : IUndoableCommand
+{
+ private readonly int _row;
+ private readonly int _col;
+ private readonly CellFormula _formula;
+ private readonly bool _calculateSheetOnSet;
+ private CellStoreRestoreData _restoreData;
+
+ public SetParsedFormulaCommand(int row, int col, CellFormula formula)
+ {
+ _row = row;
+ _col = col;
+ _formula = formula;
+ }
+
+ public bool Execute(Sheet sheet)
+ {
+ _restoreData = sheet.Cells.SetFormulaImpl(_row, _col, _formula);
+ return true;
+ }
+
+ public bool Undo(Sheet sheet)
+ {
+ sheet.Cells.Restore(_restoreData);
+ return true;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Commands/SetRowHeadingsCommand.cs b/src/BlazorDatasheet.Core/Commands/SetRowHeadingsCommand.cs
new file mode 100644
index 00000000..777e7a8c
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Commands/SetRowHeadingsCommand.cs
@@ -0,0 +1,34 @@
+using BlazorDatasheet.Core.Data;
+
+namespace BlazorDatasheet.Core.Commands;
+
+public class SetRowHeadingsCommand : IUndoableCommand
+{
+ private readonly int _rowStart;
+ private readonly int _rowEnd;
+ private readonly string _heading;
+ private List<(int start, int end, string heading)> _restoreData;
+
+ public SetRowHeadingsCommand(int rowStart, int rowEnd, string heading)
+ {
+ _rowStart = rowStart;
+ _rowEnd = rowEnd;
+ _heading = heading;
+ }
+
+ public bool Execute(Sheet sheet)
+ {
+ _restoreData = sheet.Rows.SetRowHeadingsImpl(_rowStart, _rowEnd, _heading);
+ return true;
+ }
+
+ public bool Undo(Sheet sheet)
+ {
+ foreach (var heading in _restoreData)
+ {
+ sheet.Rows.SetRowHeadingsImpl(heading.start, heading.end, heading.heading);
+ }
+
+ return true;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Commands/SetRowHeightCommand.cs b/src/BlazorDatasheet.Core/Commands/SetRowHeightCommand.cs
new file mode 100644
index 00000000..69869320
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Commands/SetRowHeightCommand.cs
@@ -0,0 +1,33 @@
+using BlazorDatasheet.Core.Data;
+
+namespace BlazorDatasheet.Core.Commands;
+
+public class SetRowHeightCommand : IUndoableCommand
+{
+ private int RowStart { get; }
+ public int RowEnd { get; }
+ private double _height { get; }
+ private List<(int start, int end, double height)> _oldHeights;
+
+ public SetRowHeightCommand(int rowStart, int rowEnd, double height)
+ {
+ RowStart = rowStart;
+ RowEnd = rowEnd;
+ _height = height;
+ }
+
+ public bool Execute(Sheet sheet)
+ {
+ _oldHeights = sheet.Rows.SetRowHeightsImpl(RowStart, RowEnd, _height);
+ return true;
+ }
+
+ public bool Undo(Sheet sheet)
+ {
+ foreach (var old in _oldHeights)
+ {
+ sheet.Rows.SetRowHeightsImpl(old.start, old.end, old.height);
+ }
+ return true;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Commands/SetTypeCommand.cs b/src/BlazorDatasheet.Core/Commands/SetTypeCommand.cs
new file mode 100644
index 00000000..310123c8
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Commands/SetTypeCommand.cs
@@ -0,0 +1,34 @@
+using BlazorDatasheet.Core.Data;
+using BlazorDatasheet.Core.Data.Cells;
+using BlazorDatasheet.DataStructures.Geometry;
+
+namespace BlazorDatasheet.Core.Commands;
+
+public class SetTypeCommand : IUndoableCommand
+{
+ private readonly IRegion _region;
+ private readonly string _type;
+ private CellStoreRestoreData _restoreData;
+
+ public SetTypeCommand(int row, int col, string type) : this(new Region(row, row, col, col), type)
+ {
+ }
+
+ public SetTypeCommand(IRegion region, string type)
+ {
+ _region = region;
+ _type = type;
+ }
+
+ public bool Execute(Sheet sheet)
+ {
+ _restoreData = sheet.Cells.SetCellTypeImpl(_region, _type);
+ return true;
+ }
+
+ public bool Undo(Sheet sheet)
+ {
+ sheet.Cells.Restore(_restoreData);
+ return true;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Commands/SetValidatorCommand.cs b/src/BlazorDatasheet.Core/Commands/SetValidatorCommand.cs
new file mode 100644
index 00000000..0c4b5979
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Commands/SetValidatorCommand.cs
@@ -0,0 +1,31 @@
+using BlazorDatasheet.Core.Data;
+using BlazorDatasheet.Core.Interfaces;
+using BlazorDatasheet.DataStructures.Geometry;
+
+namespace BlazorDatasheet.Core.Commands;
+
+public class SetValidatorCommand : IUndoableCommand
+{
+ private readonly IRegion _region;
+ private readonly IDataValidator _validator;
+
+ public SetValidatorCommand(IRegion region, IDataValidator validator)
+ {
+ _region = region;
+ _validator = validator;
+ }
+
+ public bool Execute(Sheet sheet)
+ {
+ sheet.Validators.AddImpl(_validator, _region);
+ sheet.Cells.ValidateRegion(_region);
+ return true;
+ }
+
+ public bool Undo(Sheet sheet)
+ {
+ sheet.Validators.Clear(_validator, _region);
+ sheet.Cells.ValidateRegion(_region);
+ return true;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet/Data/CellChange.cs b/src/BlazorDatasheet.Core/Data/CellValueChange.cs
similarity index 77%
rename from src/BlazorDatasheet/Data/CellChange.cs
rename to src/BlazorDatasheet.Core/Data/CellValueChange.cs
index 1b763703..c14d596e 100644
--- a/src/BlazorDatasheet/Data/CellChange.cs
+++ b/src/BlazorDatasheet.Core/Data/CellValueChange.cs
@@ -1,9 +1,9 @@
-namespace BlazorDatasheet.Data;
+namespace BlazorDatasheet.Core.Data;
///
/// Describes a change to a cell's value
///
-public class CellChange
+public class CellValueChange
{
///
/// The cell's row.
@@ -18,7 +18,7 @@ public class CellChange
///
public object? NewValue { get; }
- public CellChange(int row, int col, object? newValue)
+ public CellValueChange(int row, int col, object? newValue)
{
Row = row;
Col = col;
diff --git a/src/BlazorDatasheet.Core/Data/Cells/CellStore.Data.cs b/src/BlazorDatasheet.Core/Data/Cells/CellStore.Data.cs
new file mode 100644
index 00000000..1f154fdf
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Data/Cells/CellStore.Data.cs
@@ -0,0 +1,87 @@
+using BlazorDatasheet.Core.Commands;
+using BlazorDatasheet.DataStructures.Store;
+
+namespace BlazorDatasheet.Core.Data.Cells;
+
+public partial class CellStore
+{
+ ///
+ /// The cell DATA
+ ///
+ private readonly IMatrixDataStore _dataStore = new SparseMatrixStore();
+
+
+ ///
+ /// Sets the cell value using
+ ///
+ ///
+ ///
+ ///
+ ///
+ public bool SetValue(int row, int col, object value)
+ {
+ var cmd = new SetCellValueCommand(row, col, value);
+ return _sheet.Commands.ExecuteCommand(cmd);
+ }
+
+ ///
+ /// Sets a cell value to the value specified and raises the appropriate events.
+ ///
+ ///
+ ///
+ ///
+ /// Restore data that stores the changes made.
+ internal CellStoreRestoreData SetValueImpl(int row, int col, object value)
+ {
+ var restoreData = new CellStoreRestoreData();
+
+ // If cell values are being set while the formula engine is not calculating,
+ // then these values must override the formula and so the formula should be cleared
+ // at those cell positions.
+ if (!_sheet.FormulaEngine.IsCalculating && HasFormula(row, col))
+ {
+ restoreData.FormulaRestoreData = ClearFormulaImpl(row, col).FormulaRestoreData;
+ }
+
+ // Validate but don't stop setting cell values if the value is invalid.
+ var validationResult = _sheet.Validators.Validate(value, row, col);
+
+ // Save old validation result and current cell values.
+ restoreData.ValidRestoreData = _validStore.Set(row, col, validationResult.IsValid);
+ restoreData.ValueRestoreData = _dataStore.Set(row, col, value);
+
+ this.EmitCellChanged(row, col);
+ _sheet.MarkDirty(row, col);
+
+ return restoreData;
+ }
+
+ ///
+ /// Sets cell values to those specified using
+ ///
+ ///
+ ///
+ public bool SetValues(IEnumerable<(int row, int col, object value)> changes)
+ {
+ _sheet.Commands.BeginCommandGroup();
+ foreach (var change in changes)
+ {
+ _sheet.Commands.ExecuteCommand(new SetCellValueCommand(change.row, change.col, change.value));
+ }
+
+ _sheet.Commands.EndCommandGroup();
+
+ return true;
+ }
+
+ ///
+ /// Gets the cell's value at row, col
+ ///
+ ///
+ ///
+ ///
+ public object? GetValue(int row, int col)
+ {
+ return _dataStore.Get(row, col);
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Data/Cells/CellStore.Events.cs b/src/BlazorDatasheet.Core/Data/Cells/CellStore.Events.cs
new file mode 100644
index 00000000..bbda36a4
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Data/Cells/CellStore.Events.cs
@@ -0,0 +1,59 @@
+using BlazorDatasheet.Core.Events;
+using BlazorDatasheet.Core.Events.Formula;
+using BlazorDatasheet.DataStructures.Geometry;
+
+namespace BlazorDatasheet.Core.Data.Cells;
+
+public partial class CellStore
+{
+ public event EventHandler? MetaDataChanged;
+ public event EventHandler? FormulaChanged;
+
+ ///
+ /// If batching changes, they are stored here.
+ ///
+ private readonly HashSet _cellsChanged = new();
+
+ ///
+ /// Fired when one or more cells are changed
+ ///
+ public event EventHandler>? CellsChanged;
+
+ private bool _isBatchingChanges = false;
+
+ internal void BatchChanges()
+ {
+ if (!_isBatchingChanges)
+ {
+ _cellsChanged.Clear();
+ }
+
+ _isBatchingChanges = true;
+ }
+
+ internal void EndBatchChanges()
+ {
+ if (_cellsChanged.Any() && _isBatchingChanges)
+ CellsChanged?.Invoke(this, _cellsChanged.AsEnumerable());
+
+ _isBatchingChanges = false;
+ }
+
+ private void EmitCellChanged(int row, int col)
+ {
+ this.EmitCellsChanged(new[] { new CellPosition(row, col) });
+ }
+
+ private void EmitCellsChanged(IEnumerable positions)
+ {
+ if (_isBatchingChanges)
+ {
+ foreach (var pos in positions)
+ _cellsChanged.Add(pos);
+ }
+ else
+ {
+ CellsChanged?.Invoke(this, positions);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Data/Cells/CellStore.Format.cs b/src/BlazorDatasheet.Core/Data/Cells/CellStore.Format.cs
new file mode 100644
index 00000000..2fad90ec
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Data/Cells/CellStore.Format.cs
@@ -0,0 +1,46 @@
+using BlazorDatasheet.Core.Formats;
+using BlazorDatasheet.DataStructures.Geometry;
+using BlazorDatasheet.DataStructures.Store;
+using BlazorDatasheet.Formula.Core;
+
+namespace BlazorDatasheet.Core.Data.Cells;
+
+public partial class CellStore
+{
+ ///
+ /// Stores individual cell formats.
+ ///
+ private readonly MergeRegionDataStore _formatStore = new MergeRegionDataStore();
+
+ ///
+ /// Merges the new cell format into any existing formats
+ ///
+ ///
+ ///
+ internal CellStoreRestoreData MergeFormatImpl(IRegion region, CellFormat format)
+ {
+ _sheet.MarkDirty(region);
+ return new CellStoreRestoreData()
+ {
+ FormatRestoreData = _formatStore.Add(region, format)
+ };
+ }
+
+ ///
+ /// Returns the CELL format that is assigned to the cell.
+ /// Note this is not the visual format, because that will be merged with row/column formats.
+ /// If the format is not assigned, the default (empty) format is returned.
+ ///
+ ///
+ ///
+ ///
+ public CellFormat GetFormat(int row, int col)
+ {
+ return _formatStore.GetData(row, col).FirstOrDefault() ?? new CellFormat();
+ }
+
+ internal IEnumerable> GetFormatData(IRegion region)
+ {
+ return _formatStore.GetDataRegions(region);
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Data/Cells/CellStore.Formula.cs b/src/BlazorDatasheet.Core/Data/Cells/CellStore.Formula.cs
new file mode 100644
index 00000000..ebed5809
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Data/Cells/CellStore.Formula.cs
@@ -0,0 +1,116 @@
+using BlazorDatasheet.Core.Commands;
+using BlazorDatasheet.Core.Events.Formula;
+using BlazorDatasheet.DataStructures.Geometry;
+using BlazorDatasheet.DataStructures.Store;
+using BlazorDatasheet.Formula.Core;
+
+namespace BlazorDatasheet.Core.Data.Cells;
+
+public partial class CellStore
+{
+ ///
+ /// Cell FORMULA
+ ///
+ private readonly IMatrixDataStore _formulaStore = new SparseMatrixStore();
+
+ ///
+ /// Set the formula string for a row and col, and calculate the sheet.
+ /// If the parsed formula is invalid, the formula will not be set.
+ ///
+ ///
+ ///
+ ///
+ public void SetFormula(int row, int col, string formulaString)
+ {
+ var parsed = _sheet.FormulaEngine.ParseFormula(formulaString);
+ if (parsed.IsValid())
+ SetFormula(row, col, parsed);
+ }
+
+ ///
+ /// Sets the parsed formula for a cell. Adds the formula to the engine's dependency graph.
+ ///
+ ///
+ ///
+ ///
+ ///
+ internal CellStoreRestoreData SetFormulaImpl(int row, int col, CellFormula? formula)
+ {
+ var restoreData = new CellStoreRestoreData();
+ restoreData.ValidRestoreData = _validStore.Clear(row, col);
+ restoreData.ValueRestoreData = _dataStore.Clear(row, col);
+ restoreData.FormulaRestoreData = _formulaStore.Set(row, col, formula);
+ if (formula != null)
+ _sheet.FormulaEngine.AddToDependencyGraph(row, col, formula);
+
+ FormulaChanged?.Invoke(this,
+ new CellFormulaChangeEventArgs(row, col,
+ restoreData.FormulaRestoreData.DataRemoved.FirstOrDefault().data,
+ formula));
+ EmitCellChanged(row, col);
+
+ _sheet.MarkDirty(row, col);
+ return restoreData;
+ }
+
+ internal CellStoreRestoreData SetFormulaImpl(int row, int col, string formula)
+ {
+ var parsedFormula = _sheet.FormulaEngine.ParseFormula(formula);
+ if (parsedFormula.IsValid())
+ return SetFormulaImpl(row, col, parsedFormula);
+ return new CellStoreRestoreData();
+ }
+
+ internal CellStoreRestoreData ClearFormulaImpl(int row, int col)
+ {
+ var restoreData = _formulaStore.Clear(row, col);
+ _sheet.FormulaEngine.RemoveFromDependencyGraph(row, col);
+ return new CellStoreRestoreData() { FormulaRestoreData = restoreData };
+ }
+
+ internal CellStoreRestoreData ClearFormulaImpl(IEnumerable regions)
+ {
+ var clearedData = _formulaStore.Clear(regions);
+ foreach (var clearedFormula in clearedData.DataRemoved)
+ {
+ _sheet.FormulaEngine.RemoveFromDependencyGraph(clearedFormula.row, clearedFormula.col);
+ }
+
+ return new CellStoreRestoreData()
+ {
+ FormulaRestoreData = clearedData
+ };
+ }
+
+ ///
+ /// Whether the cell has a formula set.
+ ///
+ ///
+ ///
+ ///
+ public bool HasFormula(int row, int col)
+ {
+ return _formulaStore.Get(row, col) != null;
+ }
+
+ public string? GetFormulaString(int row, int col)
+ {
+ return _formulaStore.Get(row, col)?.ToFormulaString();
+ }
+
+ public CellFormula? GetFormula(int row, int col)
+ {
+ return _formulaStore.Get(row, col);
+ }
+
+ ///
+ /// Sets the formula for a row and col, and calculate the sheet.
+ ///
+ ///
+ ///
+ ///
+ public void SetFormula(int row, int col, CellFormula parsedFormula)
+ {
+ _sheet.Commands.ExecuteCommand(new SetParsedFormulaCommand(row, col, parsedFormula));
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Data/Cells/CellStore.Merge.cs b/src/BlazorDatasheet.Core/Data/Cells/CellStore.Merge.cs
new file mode 100644
index 00000000..8d905d97
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Data/Cells/CellStore.Merge.cs
@@ -0,0 +1,148 @@
+using BlazorDatasheet.Core.Commands;
+using BlazorDatasheet.DataStructures.Geometry;
+using BlazorDatasheet.DataStructures.Store;
+
+namespace BlazorDatasheet.Core.Data.Cells
+{
+ public partial class CellStore
+ {
+ ///
+ /// Fired when cells are merged
+ ///
+ public event EventHandler? RegionMerged;
+
+ ///
+ /// Fired when cells are un-merged
+ ///
+ public event EventHandler? RegionUnMerged;
+
+ ///
+ /// The merged cells in the sheet.
+ ///
+ private readonly RegionDataStore _mergeStore = new RegionDataStore(1, expandWhenInsertAfter: false);
+
+ ///
+ /// Add a range as a merged cell. If the range overlaps any existing merged cells, the merge
+ /// will not happen.
+ ///
+ ///
+ public void Merge(SheetRange range)
+ {
+ var merge = new MergeCellsCommand(range);
+ _sheet.Commands.ExecuteCommand(merge);
+ }
+
+ ///
+ /// Add a region as a merged cell. If the range overlaps any existing merged cells, the merge
+ /// will not happen.
+ ///
+ ///
+ public void Merge(IRegion region) => Merge(new SheetRange(_sheet, region));
+
+ internal bool MergeImpl(SheetRange range)
+ {
+ _sheet.BatchUpdates();
+ var isSuccess = true;
+ foreach (var region in range.Regions)
+ {
+ isSuccess &= MergeImpl(region);
+ }
+
+ _sheet.EndBatchUpdates();
+ return isSuccess;
+ }
+
+ internal bool MergeImpl(IRegion region)
+ {
+ _mergeStore.Add(region, true);
+ RegionMerged?.Invoke(this, region);
+ _sheet.MarkDirty(region);
+ return true;
+ }
+
+ ///
+ /// Un-merge all cells that overlap the range
+ ///
+ ///
+ internal void UnMergeCellsImpl(IRegion region)
+ {
+ var mergedCellsInRange = _mergeStore.GetDataRegions(region).ToList();
+ var updateRegion = mergedCellsInRange.FirstOrDefault()?.Region;
+ foreach (var merge in mergedCellsInRange)
+ {
+ updateRegion = region.GetBoundingRegion(updateRegion);
+ _mergeStore.Delete(merge);
+ RegionUnMerged?.Invoke(this, region);
+ }
+
+ if (updateRegion != null)
+ _sheet.MarkDirty(updateRegion);
+ }
+
+ ///
+ /// Un-merge all cells that overlap the range
+ ///
+ ///
+ internal void UnMergeCellsImpl(SheetRange range)
+ {
+ _sheet.BatchUpdates();
+ foreach (var region in range.Regions)
+ UnMergeCellsImpl((IRegion)region);
+ _sheet.EndBatchUpdates();
+ }
+
+ ///
+ /// Returns whether the position is inside a merged cell
+ ///
+ ///
+ ///
+ ///
+ public bool IsInsideMerge(int row, int col)
+ {
+ return GetMerge(row, col) != null;
+ }
+
+ ///
+ /// Returns the region (if any) that exists at the given position.
+ /// There will only be one region at most, because merges cannot overlap.
+ ///
+ ///
+ ///
+ ///
+ public IRegion? GetMerge(int row, int col)
+ {
+ var merges = _mergeStore.GetDataRegions(row, col).ToList();
+ // There will only be one merge because we don't allow overlapping
+ return merges.Any() ? merges[0].Region : null;
+ }
+
+ ///
+ /// Returns all merged regions overlapping a region.
+ ///
+ ///
+ ///
+ public IEnumerable GetMerges(IRegion region)
+ {
+ return _mergeStore.GetDataRegions(region).Select(x => x.Region);
+ }
+
+ ///
+ /// Returns all merged regions overlapping a list of regions.
+ ///
+ ///
+ ///
+ public IEnumerable GetMerges(IEnumerable regions)
+ {
+ return _mergeStore.GetDataRegions(regions).Select(x => x.Region);
+ }
+
+ ///
+ /// Returns whether the sheet has any merged cells.
+ ///
+ ///
+ public bool AnyMerges()
+ {
+ return _mergeStore.Any();
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Data/Cells/CellStore.Metadata.cs b/src/BlazorDatasheet.Core/Data/Cells/CellStore.Metadata.cs
new file mode 100644
index 00000000..76cb2e05
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Data/Cells/CellStore.Metadata.cs
@@ -0,0 +1,45 @@
+using BlazorDatasheet.Core.Commands;
+using BlazorDatasheet.Core.Metadata;
+using BlazorDatasheet.DataStructures.Geometry;
+using BlazorDatasheet.DataStructures.Store;
+
+namespace BlazorDatasheet.Core.Data.Cells;
+
+public partial class CellStore
+{
+ private readonly MergeRegionDataStore _metaDataStore = new();
+
+ ///
+ /// Sets cell metadata, specified by name, for the cell at position row, col
+ ///
+ ///
+ ///
+ ///
+ ///
+ /// Whether setting the cell metadata was successful
+ public bool SetCellMetaData(int row, int col, string name, object? value)
+ {
+ var cmd = new SetMetaDataCommand(row, col, name, value);
+ return _sheet.Commands.ExecuteCommand(cmd);
+ }
+
+ internal void SetMetaDataImpl(int row, int col, string name, object? value)
+ {
+ var newMetaData = new CellMetadata();
+ newMetaData.SetItem(name, value);
+ _metaDataStore.Add(new Region(row, col), newMetaData);
+ }
+
+ ///
+ /// Returns the metadata with key "name" for the cell at row, col.
+ ///
+ ///
+ ///
+ ///
+ ///
+ public object? GetMetaData(int row, int col, string name)
+ {
+ var container = _metaDataStore.GetData(row, col).FirstOrDefault() ?? new CellMetadata();
+ return container.GetItem(name);
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Data/Cells/CellStore.Types.cs b/src/BlazorDatasheet.Core/Data/Cells/CellStore.Types.cs
new file mode 100644
index 00000000..4894bf4e
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Data/Cells/CellStore.Types.cs
@@ -0,0 +1,65 @@
+using BlazorDatasheet.Core.Commands;
+using BlazorDatasheet.DataStructures.Geometry;
+using BlazorDatasheet.DataStructures.Store;
+
+namespace BlazorDatasheet.Core.Data.Cells;
+
+public partial class CellStore
+{
+ private readonly ConsolidatedDataStore _typeStore = new();
+
+ public string GetCellType(int row, int col)
+ {
+ var type = _typeStore.Get(row, col);
+ return type ?? "text";
+ }
+
+ ///
+ /// Sets the cell type in a region, to the value specified.
+ ///
+ ///
+ ///
+ ///
+ internal CellStoreRestoreData SetCellTypeImpl(IRegion region, string type)
+ {
+ var restoreData = new CellStoreRestoreData();
+ restoreData.TypeRestoreData = _typeStore.Add(region, type);
+ _sheet.MarkDirty(region);
+ return restoreData;
+ }
+
+ ///
+ /// Sets the cell type in a , to the specified.
+ ///
+ ///
+ ///
+ ///
+ public void SetType(IRegion region, string type)
+ {
+ _sheet.Commands.ExecuteCommand(new SetTypeCommand(region, type));
+ }
+
+ ///
+ /// Sets the cell type in a , to the specified.
+ ///
+ ///
+ ///
+ ///
+ public void SetType(IEnumerable regions, string type)
+ {
+ _sheet.Commands.BeginCommandGroup();
+ foreach (var region in regions)
+ {
+ _sheet.Commands.ExecuteCommand(new SetTypeCommand(region, type));
+ }
+ _sheet.Commands.EndCommandGroup();
+ }
+
+ ///
+ /// Sets the cell type for a amd
+ ///
+ ///
+ ///
+ ///
+ public void SetType(int row, int col, string type) => SetType(new Region(row, col), type);
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Data/Cells/CellStore.Validation.cs b/src/BlazorDatasheet.Core/Data/Cells/CellStore.Validation.cs
new file mode 100644
index 00000000..69a104de
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Data/Cells/CellStore.Validation.cs
@@ -0,0 +1,33 @@
+using BlazorDatasheet.Core.Commands;
+using BlazorDatasheet.Core.Interfaces;
+using BlazorDatasheet.DataStructures.Geometry;
+using BlazorDatasheet.DataStructures.Store;
+
+namespace BlazorDatasheet.Core.Data.Cells;
+
+public partial class CellStore
+{
+ ///
+ /// Stores whether cells are valid.
+ ///
+ private readonly IMatrixDataStore _validStore = new SparseMatrixStore();
+
+ internal void ValidateRegion(IRegion region)
+ {
+ var cellsAffected = _dataStore.GetNonEmptyPositions(region).ToList();
+ foreach (var (row, col) in cellsAffected)
+ {
+ var cellData = _dataStore.Get(row, col);
+ var result = _sheet.Validators.Validate(cellData, row, col);
+ _validStore.Set(row, col, result.IsValid);
+ }
+
+ _sheet.MarkDirty(cellsAffected);
+ }
+
+ public bool IsValid(int row, int col)
+ {
+ var valid = _validStore.Get(row, col);
+ return valid != false;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Data/Cells/CellStore.cs b/src/BlazorDatasheet.Core/Data/Cells/CellStore.cs
new file mode 100644
index 00000000..08d274ed
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Data/Cells/CellStore.cs
@@ -0,0 +1,205 @@
+using BlazorDatasheet.Core.Commands;
+using BlazorDatasheet.Core.Formats;
+using BlazorDatasheet.Core.Interfaces;
+using BlazorDatasheet.Core.Validation;
+using BlazorDatasheet.DataStructures.Geometry;
+using BlazorDatasheet.DataStructures.Store;
+using BlazorDatasheet.Formula.Core;
+
+namespace BlazorDatasheet.Core.Data.Cells;
+
+public partial class CellStore
+{
+ private Sheet _sheet;
+
+ public CellStore(Sheet sheet)
+ {
+ _sheet = sheet;
+ }
+
+ ///
+ /// Returns all cells in the specified region
+ ///
+ ///
+ ///
+ public IEnumerable GetCellsInRegion(IRegion region)
+ {
+ return (new SheetRange(_sheet, region))
+ .Positions
+ .Select(x => this.GetCell(x.row, x.col));
+ }
+
+ ///
+ /// Returns all cells that are present in the regions given.
+ ///
+ ///
+ ///
+ public IEnumerable GetCellsInRegions(IEnumerable regions)
+ {
+ var cells = new List();
+ foreach (var region in regions)
+ cells.AddRange(GetCellsInRegion(region));
+ return cells.ToArray();
+ }
+
+ ///
+ /// Returns the cell at the specified position.
+ ///
+ ///
+ ///
+ ///
+ public IReadOnlyCell GetCell(int row, int col)
+ {
+ return new SheetCell(row, col, _sheet);
+ }
+
+ ///
+ /// Returns the cell at the specified position
+ ///
+ ///
+ ///
+ public IReadOnlyCell GetCell(CellPosition position)
+ {
+ return GetCell(position.row, position.col);
+ }
+
+ internal IEnumerable GetNonEmptyCellPositions(IRegion region)
+ {
+ return _dataStore.GetNonEmptyPositions(region.TopLeft.row,
+ region.BottomRight.row,
+ region.TopLeft.col,
+ region.BottomRight.col);
+ }
+
+ ///
+ /// Clears all cell values in the region
+ ///
+ /// The range in which to clear all cells
+ public void ClearCells(SheetRange range)
+ {
+ var cmd = new ClearCellsCommand(range);
+ _sheet.Commands.ExecuteCommand(cmd);
+ }
+
+ internal CellStoreRestoreData ClearCellsImpl(IEnumerable regionsToClear)
+ {
+ _sheet.BatchUpdates();
+ var restoreData = new CellStoreRestoreData();
+ var toClear = regionsToClear.ToList();
+ restoreData.ValueRestoreData = _dataStore.Clear(toClear);
+ restoreData.ValidRestoreData = _validStore.Clear(toClear);
+ restoreData.FormulaRestoreData = ClearFormulaImpl(toClear).FormulaRestoreData;
+
+ var affected = restoreData.GetAffectedPositions().ToList();
+ EmitCellsChanged(affected);
+ _sheet.MarkDirty(affected);
+
+ _sheet.EndBatchUpdates();
+ return restoreData;
+ }
+
+ ///
+ /// Inserts a number of columns into each of the cell's stores.
+ ///
+ /// The column that will be replaced by the new column.
+ /// The number of columns to insert
+ /// Whether to expand any cell data to the left of the insertion. If undoing an action, best to set to false.
+ internal void InsertColAt(int col, int nCols, bool? expandNeighboring = null)
+ {
+ _dataStore.InsertColAt(col, nCols);
+ _formatStore.InsertCols(col, nCols, expandNeighboring);
+ _typeStore.InsertCols(col, nCols, expandNeighboring);
+ _formulaStore.InsertColAt(col, nCols);
+ _validStore.InsertColAt(col, nCols);
+ _mergeStore.InsertCols(col, nCols, false);
+ }
+
+ ///
+ /// Inserts a number of rows into each of the cell's stores.
+ ///
+ /// The row that will be replaced by the new row.
+ /// The number of rows to insert
+ /// Whether to expand any cell data to the left of the insertion. If undoing an action, best to set to false.
+ internal void InsertRowAt(int row, int nRows, bool? expandNeighboring = null)
+ {
+ _dataStore.InsertRowAt(row, nRows);
+ _formatStore.InsertRows(row, nRows, expandNeighboring);
+ _typeStore.InsertRows(row, nRows, expandNeighboring);
+ _formulaStore.InsertRowAt(row, nRows);
+ _validStore.InsertRowAt(row, nRows);
+ _mergeStore.InsertRows(row, nRows, false);
+ }
+
+ internal CellStoreRestoreData RemoveRowAt(int row, int nRows)
+ {
+ var restoreData = new CellStoreRestoreData();
+ restoreData.ValueRestoreData = _dataStore.RemoveRowAt(row, nRows);
+ restoreData.ValidRestoreData = _validStore.RemoveRowAt(row, nRows);
+ restoreData.TypeRestoreData = _typeStore.RemoveRows(row, row + nRows - 1);
+ restoreData.FormulaRestoreData = ClearFormulaImpl(row, nRows).FormulaRestoreData;
+ restoreData.FormatRestoreData = _formatStore.RemoveRows(row, row + nRows - 1);
+ restoreData.MergeRestoreData = _mergeStore.RemoveRows(row, row + nRows - 1);
+ _formulaStore.RemoveRowAt(row, nRows);
+
+ return restoreData;
+ }
+
+ internal CellStoreRestoreData RemoveColAt(int col, int nCols)
+ {
+ var restoreData = new CellStoreRestoreData();
+ restoreData.ValueRestoreData = _dataStore.RemoveColAt(col, nCols);
+ restoreData.ValidRestoreData = _validStore.RemoveColAt(col, nCols);
+ restoreData.TypeRestoreData = _typeStore.RemoveCols(col, col + nCols - 1);
+ restoreData.FormulaRestoreData = ClearFormulaImpl(col, nCols).FormulaRestoreData;
+ restoreData.FormatRestoreData = _formatStore.RemoveCols(col, col + nCols - 1);
+ restoreData.MergeRestoreData = _mergeStore.RemoveCols(col, col + nCols - 1);
+ _formulaStore.RemoveColAt(col, nCols);
+
+ return restoreData;
+ }
+
+ ///
+ /// Restores the internal storage state by redoing any actions that caused the internal data to change.
+ /// Fires events for the changed data.
+ ///
+ ///
+ internal void Restore(CellStoreRestoreData restoreData)
+ {
+ var batches = _sheet.BatchUpdates();
+
+ // Set formula through this function so we add the formula back in to the dependency graph
+ foreach (var data in restoreData.FormulaRestoreData.DataRemoved)
+ this.SetFormulaImpl(data.row, data.col, data.data);
+
+ _validStore.Restore(restoreData.ValidRestoreData);
+ _typeStore.Restore(restoreData.TypeRestoreData);
+ _dataStore.Restore(restoreData.ValueRestoreData);
+ _formatStore.Restore(restoreData.FormatRestoreData);
+ _mergeStore.Restore(restoreData.MergeRestoreData);
+
+ foreach (var pt in restoreData.ValueRestoreData.DataRemoved)
+ {
+ _sheet.MarkDirty(pt.row, pt.col);
+ EmitCellChanged(pt.row, pt.col);
+ }
+
+ foreach (var region in restoreData.GetAffectedRegions())
+ {
+ _sheet.MarkDirty(region);
+ }
+
+ if (batches) // if this is false, a higher power is batching changes.
+ _sheet.EndBatchUpdates();
+ }
+
+
+ ///
+ /// The at position row, col.
+ ///
+ ///
+ ///
+ public SheetCell this[int row, int col]
+ {
+ get { return new SheetCell(row, col, _sheet); }
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Data/Cells/CellStoreRestoreData.cs b/src/BlazorDatasheet.Core/Data/Cells/CellStoreRestoreData.cs
new file mode 100644
index 00000000..9ccdd532
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Data/Cells/CellStoreRestoreData.cs
@@ -0,0 +1,31 @@
+using BlazorDatasheet.Core.Formats;
+using BlazorDatasheet.DataStructures.Geometry;
+using BlazorDatasheet.DataStructures.Store;
+using BlazorDatasheet.Formula.Core;
+
+namespace BlazorDatasheet.Core.Data.Cells;
+
+internal class CellStoreRestoreData
+{
+ internal MatrixRestoreData ValueRestoreData { get; set; } = new();
+ internal MatrixRestoreData FormulaRestoreData { get; set; } = new();
+ internal MatrixRestoreData ValidRestoreData { get; set; } = new();
+ internal RegionRestoreData TypeRestoreData { get; set; } = new();
+ internal RegionRestoreData FormatRestoreData { get; set; } = new();
+ internal RegionRestoreData MergeRestoreData { get; set; } = new();
+
+ internal IEnumerable GetAffectedPositions()
+ {
+ return ValidRestoreData.DataRemoved.Select(x => new CellPosition(x.row, x.col))
+ .Concat(ValueRestoreData.DataRemoved.Select(x => new CellPosition(x.row, x.col))
+ .Concat(FormulaRestoreData.DataRemoved.Select(x => new CellPosition(x.row, x.col))));
+ }
+
+ internal IEnumerable GetAffectedRegions()
+ {
+ return TypeRestoreData.RegionsAdded.Select(x => x.Region)
+ .Concat(TypeRestoreData.RegionsRemoved.Select(x => x.Region))
+ .Concat(FormatRestoreData.RegionsAdded.Select(x => x.Region))
+ .Concat(FormatRestoreData.RegionsRemoved.Select(x => x.Region));
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Data/ColumnInfoStore.cs b/src/BlazorDatasheet.Core/Data/ColumnInfoStore.cs
new file mode 100644
index 00000000..eef73cd6
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Data/ColumnInfoStore.cs
@@ -0,0 +1,312 @@
+using BlazorDatasheet.Core.Commands;
+using BlazorDatasheet.Core.Data.Cells;
+using BlazorDatasheet.Core.Events.Layout;
+using BlazorDatasheet.Core.Formats;
+using BlazorDatasheet.DataStructures.Geometry;
+using BlazorDatasheet.DataStructures.Intervals;
+using BlazorDatasheet.DataStructures.Store;
+
+namespace BlazorDatasheet.Core.Data;
+
+public class ColumnInfoStore
+{
+ private readonly Sheet _sheet;
+ public double DefaultWidth { get; }
+ private readonly Range1DStore _headingStore = new(null);
+ private readonly CumulativeRange1DStore _widthStore;
+ internal readonly MergeableIntervalStore ColFormats = new();
+
+ ///
+ /// Fired when a column is inserted into the sheet
+ ///
+ public event EventHandler? ColumnInserted;
+
+ ///
+ /// Fired when a column is removed from the sheet.
+ ///
+ public event EventHandler? ColumnRemoved;
+
+ ///
+ /// Fired when a column width is changed
+ ///
+ public event EventHandler? ColumnWidthChanged;
+
+
+ public ColumnInfoStore(double defaultWidth, Sheet sheet)
+ {
+ _sheet = sheet;
+ DefaultWidth = defaultWidth;
+ _widthStore = new CumulativeRange1DStore(defaultWidth);
+ }
+
+ ///
+ /// Sets column width of one column and returns any column widths that were modified when set.
+ ///
+ ///
+ ///
+ ///
+ internal List<(int start, int end, double width)> SetColumnWidthImpl(int col, double width)
+ {
+ var restoreData = _widthStore.Set(col, width);
+ _sheet.MarkDirty(new ColumnRegion(col, _sheet.NumCols));
+ return restoreData;
+ }
+
+ ///
+ /// Sets the column widths of all columns between (and including) the columns specified, to the value given.
+ /// Returns any column ranges that were modified.
+ ///
+ ///
+ ///
+ ///
+ ///
+ internal List<(int start, int end, double width)> SetColumnWidthsImpl(int colStart, int colEnd, double width)
+ {
+ var restoreData = _widthStore.Set(colStart, colEnd, width);
+ ColumnWidthChanged?.Invoke(this, new ColumnWidthChangedEventArgs(colStart, colEnd, width));
+ _sheet.MarkDirty(new ColumnRegion(colStart, _sheet.NumCols));
+ return restoreData;
+ }
+
+ ///
+ /// Sets the hae
+ ///
+ ///
+ ///
+ ///
+ internal List<(int start, int end, string heading)> SetColumnHeadingImpl(int col, string heading)
+ {
+ var restoreData = _headingStore.Set(col, heading);
+ _sheet.MarkDirty(new ColumnRegion(col));
+ return restoreData;
+ }
+
+ ///
+ /// Sets the headings of all columns between (and including) the columns specified, to the value given.
+ /// Returns any column ranges that were modified.
+ ///
+ ///
+ ///
+ ///
+ ///
+ internal List<(int start, int end, string heading)> SetColumnHeadingsImpl(int colStart, int colEnd, string heading)
+ {
+ var restoreData = _headingStore.Set(colStart, colEnd, heading);
+ _sheet.MarkDirty(new ColumnRegion(colStart, colEnd));
+ return restoreData;
+ }
+
+ ///
+ /// Removes the columns between (and including) the indexes given.
+ /// Handles shifting the column indices to the left and returns any modified data.
+ ///
+ ///
+ ///
+ ///
+ internal ColumnInfoRestoreData RemoveColumnsImpl(int start, int end)
+ {
+ var restoreData = new ColumnInfoRestoreData()
+ {
+ WidthsModified = _widthStore.Delete(start, end),
+ HeadingsModifed = _headingStore.Delete(start, end),
+ ColFormatRestoreData = new RowColFormatRestoreData()
+ {
+ IntervalsRemoved = ColFormats.Clear(start, end)
+ }
+ };
+
+ ColFormats.ShiftLeft(start, (end - start) + 1);
+ ColumnRemoved?.Invoke(this, new ColumnRemovedEventArgs(start, (start - end) + 1));
+ _sheet.MarkDirty(new ColumnRegion(start, _sheet.NumCols));
+ return restoreData;
+ }
+
+ ///
+ /// Inserts a column after the index specified. If the index is outside of the range of -1 to NumCols-1,
+ /// A column is added either at the beginning or end of the columns.
+ ///
+ ///
+ ///
+ public void InsertAt(int colIndex, int nCols = 1)
+ {
+ var indexToAdd = Math.Min(_sheet.NumCols - 1, Math.Max(colIndex, 0));
+ var cmd = new InsertColAtCommand(indexToAdd, nCols);
+ _sheet.Commands.ExecuteCommand(cmd);
+ }
+
+ ///
+ /// Inserts n empty columns.
+ ///
+ ///
+ ///
+ internal void InsertImpl(int start, int n)
+ {
+ _widthStore.InsertAt(start, n);
+ _headingStore.InsertAt(start, n);
+ ColFormats.ShiftRight(start, n);
+ ColumnInserted?.Invoke(this, new ColumnInsertedEventArgs(start, n));
+ _sheet.MarkDirty(new ColumnRegion(start, _sheet.NumCols));
+ }
+
+ ///
+ /// Returns the heading at the column index
+ ///
+ ///
+ ///
+ public string? GetHeading(int columnIndex)
+ {
+ return _headingStore.Get(columnIndex);
+ }
+
+ ///
+ /// Returns the column index at the position x
+ ///
+ ///
+ ///
+ public int GetColumn(double x)
+ {
+ return _widthStore.GetPosition(x);
+ }
+
+ ///
+ /// Returns the width of the column specified.
+ ///
+ ///
+ ///
+ public double GetWidth(int column)
+ {
+ return _widthStore.GetSize(column);
+ }
+
+ ///
+ /// Returns the distance between the left positions of two columns.
+ ///
+ ///
+ ///
+ ///
+ public double GetWidthBetween(int start, int end)
+ {
+ return _widthStore.GetSizeBetween(start, end);
+ }
+
+ ///
+ /// Returns the left position of the column index
+ ///
+ ///
+ ///
+ public double GetLeft(int colIndex)
+ {
+ return _widthStore.GetCumulative(colIndex);
+ }
+
+ internal void Restore(ColumnInfoRestoreData data)
+ {
+ _widthStore.BatchSet(data.WidthsModified);
+ _headingStore.BatchSet(data.HeadingsModifed);
+ foreach (var added in data.ColFormatRestoreData.IntervalsAdded)
+ ColFormats.Clear(added);
+ ColFormats.AddRange(data.ColFormatRestoreData.IntervalsRemoved);
+
+ foreach(var change in data.WidthsModified)
+ ColumnWidthChanged?.Invoke(this, new ColumnWidthChangedEventArgs(change.start, change.end, change.width));
+ }
+
+ public CellFormat? GetFormat(int column)
+ {
+ return ColFormats.Get(column);
+ }
+
+ internal RowColFormatRestoreData SetColumnFormatImpl(CellFormat cellFormat, ColumnRegion colRegion)
+ {
+ // Keep track of individual cell changes
+ var cellChanges = new List();
+
+ // we will ALWAYS merge the column regardless of what the cells are doing.
+ var newOi = new OrderedInterval(colRegion.Left, colRegion.Right, cellFormat.Clone());
+ var modified = ColFormats.Add(newOi);
+
+ // We need to find the merges between the new region and the row formats/cell formats and add those as cell formats.
+ // this is because we the order of choosing the cell format is 1. cell format, then 2. col format then 3. row format.
+ // if we set col format then a row format with some intersection, we would find that the col format is chosen when we
+ // query the format at the intersection. It should be the cell format, so we set that.
+ var rowOverlaps = _sheet.Rows.RowFormats.GetAllIntervals()
+ .Select(x =>
+ new DataRegion(x.Data, new Region(x.Start, x.End, colRegion.Left, colRegion.Right)));
+
+ var cellOverlaps = _sheet.Cells.GetFormatData(colRegion)
+ .Select(x => new DataRegion(x.Data, x.Region.GetIntersection(colRegion)!));
+
+ // The intersectings region should be be merged with any existing (or empty) cell formats
+ // So that the new, most recently applied format info is taken when the format is queried.
+ // There may be some cell formats inside the col/row intersections in which case the format will be merged twice.
+ // That should be ok because they will already exist and won't be added
+ foreach (var overlap in rowOverlaps.Concat(cellOverlaps))
+ {
+ cellChanges.Add(_sheet.Cells.MergeFormatImpl(overlap.Region, cellFormat));
+ }
+
+ _sheet.MarkDirty(colRegion);
+
+ return new RowColFormatRestoreData()
+ {
+ CellFormatRestoreData = cellChanges,
+ IntervalsAdded = new List>() { newOi },
+ IntervalsRemoved = modified
+ };
+ }
+
+ ///
+ /// Removes the column at the specified index
+ ///
+ ///
+ /// The number of oclumns to remove
+ /// Whether the column removal was successful
+ public bool RemoveAt(int colIndex, int nCols = 1)
+ {
+ var cmd = new RemoveColumnCommand(colIndex, nCols);
+ return _sheet.Commands.ExecuteCommand(cmd);
+ }
+
+ ///
+ /// Sets the width of a column, to the width given (in px).
+ ///
+ ///
+ ///
+ ///
+ public void SetWidth(int colStart, int colEnd, double width)
+ {
+ var cmd = new SetColumnWidthCommand(colStart, colEnd, width);
+ _sheet.Commands.ExecuteCommand(cmd);
+ }
+
+ ///
+ /// Sets the width of a column, to the width given (in px).
+ ///
+ ///
+ ///
+ ///
+ public void SetWidth(int column, double width)
+ {
+ var cmd = new SetColumnWidthCommand(column, column, width);
+ _sheet.Commands.ExecuteCommand(cmd);
+ }
+
+ ///
+ /// Sets the column headings from (and including) to to
+ ///
+ ///
+ ///
+ ///
+ public void SetHeadings(int colStart, int colEnd, string heading)
+ {
+ _sheet.Commands.ExecuteCommand(new SetColumnHeadingsCommand(colStart, colEnd, heading));
+ }
+}
+
+internal class ColumnInfoRestoreData
+{
+ public List<(int start, int end, double width)> WidthsModified { get; init; }
+ public List<(int start, int end, string heading)> HeadingsModifed { get; init; }
+
+ public RowColFormatRestoreData ColFormatRestoreData { get; init; }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet/Data/RangePositionEnumerator.cs b/src/BlazorDatasheet.Core/Data/RangePositionEnumerator.cs
similarity index 61%
rename from src/BlazorDatasheet/Data/RangePositionEnumerator.cs
rename to src/BlazorDatasheet.Core/Data/RangePositionEnumerator.cs
index 64c49139..dbc96db0 100644
--- a/src/BlazorDatasheet/Data/RangePositionEnumerator.cs
+++ b/src/BlazorDatasheet.Core/Data/RangePositionEnumerator.cs
@@ -1,30 +1,31 @@
using System.Collections;
+using BlazorDatasheet.DataStructures.Geometry;
-namespace BlazorDatasheet.Data;
+namespace BlazorDatasheet.Core.Data;
-internal class RangePositionEnumerator : IEnumerable<(int row, int col)>
+internal class RangePositionEnumerator : IEnumerable
{
- private readonly BRange _range;
+ private readonly SheetRange _range;
- internal RangePositionEnumerator(BRange range)
+ internal RangePositionEnumerator(SheetRange range)
{
_range = range;
}
- public IEnumerator<(int row, int col)> GetEnumerator()
+ public IEnumerator GetEnumerator()
{
foreach (var region in _range.Regions)
{
var fixedRegion = _range.Sheet.Region.GetIntersection(region);
- var row = fixedRegion.TopLeft.Row;
- var col = fixedRegion.TopLeft.Col;
+ var row = fixedRegion.TopLeft.row;
+ var col = fixedRegion.TopLeft.col;
var w = fixedRegion.Width;
var h = fixedRegion.Height;
for (var i = 0; i < h; i++)
{
// Reset column at start of each row
- col = fixedRegion.TopLeft.Col;
+ col = fixedRegion.TopLeft.col;
for (var j = 0; j < w; j++)
{
yield return new(row, col);
diff --git a/src/BlazorDatasheet.Core/Data/RowInfoStore.cs b/src/BlazorDatasheet.Core/Data/RowInfoStore.cs
new file mode 100644
index 00000000..36e77013
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Data/RowInfoStore.cs
@@ -0,0 +1,298 @@
+using BlazorDatasheet.Core.Commands;
+using BlazorDatasheet.Core.Data.Cells;
+using BlazorDatasheet.Core.Events.Layout;
+using BlazorDatasheet.Core.Formats;
+using BlazorDatasheet.DataStructures.Geometry;
+using BlazorDatasheet.DataStructures.Intervals;
+using BlazorDatasheet.DataStructures.Store;
+
+namespace BlazorDatasheet.Core.Data;
+
+public class RowInfoStore
+{
+ private readonly Sheet _sheet;
+ public double DefaultHeight { get; }
+ private readonly Range1DStore _headingStore = new(null);
+ private readonly CumulativeRange1DStore _heightStore;
+ internal readonly MergeableIntervalStore RowFormats = new();
+
+ ///
+ /// Fired when a row is inserted into the sheet
+ ///
+ public event EventHandler? RowInserted;
+
+ ///
+ /// Fired when a row is removed from the sheet.
+ ///
+ public event EventHandler? RowRemoved;
+
+ ///
+ /// Fired when a row height is changed.
+ ///
+ public event EventHandler RowHeightChanged;
+
+ public RowInfoStore(double defaultHeight, Sheet sheet)
+ {
+ _sheet = sheet;
+ DefaultHeight = defaultHeight;
+ _heightStore = new CumulativeRange1DStore(defaultHeight);
+ }
+
+ ///
+ /// Sets row height of one row and returns any row widths that were modified when set.
+ ///
+ ///
+ ///
+ ///
+ internal List<(int start, int end, double width)> SetRowHeightImpl(int row, double height)
+ {
+ var restoreData = _heightStore.Set(row, height);
+ _sheet.MarkDirty(new RowRegion(row, _sheet.NumRows));
+ return restoreData;
+ }
+
+ ///
+ /// Sets the row heights of all rows between (and including) the rows specified, to the value given.
+ /// Returns any row ranges that were modified.
+ ///
+ ///
+ ///
+ ///
+ ///
+ internal List<(int start, int end, double width)> SetRowHeightsImpl(int rowStart, int rowEnd, double height)
+ {
+ var restoreData = _heightStore.Set(rowStart, rowEnd, height);
+ RowHeightChanged?.Invoke(this, new RowHeightChangedEventArgs(rowStart, rowEnd, height));
+ _sheet.MarkDirty(new RowRegion(rowStart, rowEnd));
+ return restoreData;
+ }
+
+ ///
+ /// Sets the heading for a row.
+ ///
+ ///
+ ///
+ ///
+ internal List<(int start, int end, string heading)> SetRowHeadingImpl(int row, string heading)
+ {
+ var restoreData = _headingStore.Set(row, heading);
+ _sheet.MarkDirty(new RowRegion(row));
+ return restoreData;
+ }
+
+ ///
+ /// Sets the headings of all rows between (and including) rows columns specified, to the value given.
+ /// Returns any rows ranges that were modified.
+ ///
+ ///
+ ///
+ ///
+ ///
+ internal List<(int start, int end, string heading)> SetRowHeadingsImpl(int rowStart, int rowEnd, string heading)
+ {
+ var restoreData = _headingStore.Set(rowStart, rowEnd, heading);
+ _sheet.MarkDirty(new RowRegion(rowStart, rowEnd));
+ return restoreData;
+ }
+
+ ///
+ /// Removes the columns between (and including) the indexes given.
+ /// Handles shifting the row indices to the left and returns any modified data.
+ ///
+ ///
+ ///
+ ///
+ internal RowInfoStoreRestoreData RemoveRowsImpl(int start, int end)
+ {
+ var res = new RowInfoStoreRestoreData()
+ {
+ HeightsModified = _heightStore.Delete(start, end),
+ HeadingsModifed = _headingStore.Delete(start, end),
+ RowFormatRestoreData = new RowColFormatRestoreData()
+ {
+ IntervalsRemoved = RowFormats.Clear(start, end)
+ }
+ };
+
+ RowFormats.ShiftLeft(start, (end - start) + 1);
+ RowRemoved?.Invoke(this, new RowRemovedEventArgs(start, (start - end) + 1));
+ _sheet.MarkDirty(new RowRegion(start, _sheet.NumRows));
+ return res;
+ }
+
+ ///
+ /// Inserts n empty rows.
+ ///
+ ///
+ ///
+ internal void InsertImpl(int start, int n)
+ {
+ _heightStore.InsertAt(start, n);
+ _headingStore.InsertAt(start, n);
+ RowFormats.ShiftRight(start, n);
+ RowInserted?.Invoke(this, new RowInsertedEventArgs(start, n));
+ _sheet.MarkDirty(new RowRegion(start, _sheet.NumRows));
+ }
+
+ ///
+ /// Returns the heading at the row index
+ ///
+ ///
+ ///
+ public string? GetHeading(int rowIndex)
+ {
+ return _headingStore.Get(rowIndex);
+ }
+
+ ///
+ /// Returns the row index at the position y
+ ///
+ ///
+ ///
+ public int GetRow(double y)
+ {
+ return _heightStore.GetPosition(y);
+ }
+
+ ///
+ /// Returns the height of the row specified.
+ ///
+ ///
+ ///
+ public double GetHeight(int row)
+ {
+ return _heightStore.GetSize(row);
+ }
+
+ ///
+ /// Returns the distance between the top positions of two rows.
+ ///
+ ///
+ ///
+ ///
+ public double GetHeightBetween(int start, int end)
+ {
+ return _heightStore.GetSizeBetween(start, end);
+ }
+
+ ///
+ /// Returns the left position of the column index
+ ///
+ ///
+ ///
+ public double GetTop(int rowIndex)
+ {
+ return _heightStore.GetCumulative(rowIndex);
+ }
+
+ internal void Restore(RowInfoStoreRestoreData data)
+ {
+ _heightStore.BatchSet(data.HeightsModified);
+ _headingStore.BatchSet(data.HeadingsModifed);
+ foreach (var added in data.RowFormatRestoreData.IntervalsAdded)
+ RowFormats.Clear(added);
+ RowFormats.AddRange(data.RowFormatRestoreData.IntervalsRemoved);
+
+ foreach (var change in data.HeightsModified)
+ RowHeightChanged?.Invoke(this, new RowHeightChangedEventArgs(change.start, change.end, change.height));
+ }
+
+ public CellFormat? GetFormat(int column)
+ {
+ return RowFormats.Get(column);
+ }
+
+ internal RowColFormatRestoreData SetRowFormatImpl(CellFormat cellFormat, RowRegion rowRegion)
+ {
+ // Keep track of individual cell changes
+ var cellChanges = new List();
+
+ // we will ALWAYS merge the column regardless of what the cells are doing.
+ var newOi = new OrderedInterval(rowRegion.Top, rowRegion.Bottom, cellFormat.Clone());
+ var modified = RowFormats.Add(newOi);
+
+ // We need to find the merges between the new region and the row formats/cell formats and add those as cell formats.
+ // this is because we the order of choosing the cell format is 1. cell format, then 2. col format then 3. row format.
+ // if we set col format then a row format with some intersection, we would find that the col format is chosen when we
+ // query the format at the intersection. It should be the cell format, so we set that.
+ var colOverlaps = _sheet.Columns.ColFormats.GetAllIntervals()
+ .Select(x =>
+ new DataRegion(x.Data, new Region(rowRegion.Top, rowRegion.Bottom, x.Start, x.End)));
+
+ var cellOverlaps = _sheet.Cells.GetFormatData(rowRegion)
+ .Select(x => new DataRegion(x.Data, x.Region.GetIntersection(rowRegion)!));
+
+ // The intersectings region should be be merged with any existing (or empty) cell formats
+ // So that the new, most recently applied format info is taken when the format is queried.
+ // There may be some cell formats inside the col/row intersections in which case the format will be merged twice.
+ // That should be ok because they will already exist and won't be added
+ foreach (var overlap in colOverlaps.Concat(cellOverlaps))
+ {
+ cellChanges.Add(_sheet.Cells.MergeFormatImpl(overlap.Region, cellFormat));
+ }
+
+ _sheet.MarkDirty(rowRegion);
+
+ return new RowColFormatRestoreData()
+ {
+ CellFormatRestoreData = cellChanges,
+ IntervalsAdded = new List>() { newOi },
+ IntervalsRemoved = modified
+ };
+ }
+
+ public bool RemoveAt(int index, int nRows = 1)
+ {
+ var cmd = new RemoveRowsCommand(index, nRows);
+ return _sheet.Commands.ExecuteCommand(cmd);
+ }
+
+ ///
+ /// Inserts a row at an index specified.
+ ///
+ /// The index that the new row will be at. The new row will have the index specified.
+ public void InsertRowAt(int rowIndex, int nRows = 1)
+ {
+ var indexToAddAt = Math.Min(_sheet.NumRows - 1, Math.Max(rowIndex, 0));
+ var cmd = new InsertRowsAtCommand(indexToAddAt, nRows);
+ _sheet.Commands.ExecuteCommand(cmd);
+ }
+
+ ///
+ /// Sets the height of a row, to the height given (in px).
+ ///
+ ///
+ ///
+ ///
+ public void SetHeight(int rowStart, int rowEnd, double height)
+ {
+ var cmd = new SetRowHeightCommand(rowStart, rowEnd, height);
+ _sheet.Commands.ExecuteCommand(cmd);
+ }
+
+ ///
+ /// Sets the height of a row, to the height given (in px).
+ ///
+ ///
+ ///
+ ///
+ public void SetHeight(int row, double height) => SetHeight(row, row, height);
+
+ ///
+ /// Sets the row headings from (and including) to to
+ ///
+ ///
+ ///
+ ///
+ public void SetHeadings(int rowStart, int rowEnd, string heading)
+ {
+ _sheet.Commands.ExecuteCommand(new SetRowHeadingsCommand(rowStart, rowEnd, heading));
+ }
+}
+
+internal class RowInfoStoreRestoreData
+{
+ public List<(int start, int end, double height)> HeightsModified { get; init; }
+ public List<(int start, int end, string heading)> HeadingsModifed { get; init; }
+ public RowColFormatRestoreData RowFormatRestoreData { get; init; }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Data/Sheet.cs b/src/BlazorDatasheet.Core/Data/Sheet.cs
new file mode 100644
index 00000000..1dcfaed2
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Data/Sheet.cs
@@ -0,0 +1,486 @@
+using System.Diagnostics;
+using System.Text;
+using BlazorDatasheet.Core.Commands;
+using BlazorDatasheet.Core.Data.Cells;
+using BlazorDatasheet.Core.Edit;
+using BlazorDatasheet.Core.Events.Visual;
+using BlazorDatasheet.Core.Formats;
+using BlazorDatasheet.Core.Interfaces;
+using BlazorDatasheet.Core.Selecting;
+using BlazorDatasheet.Core.Validation;
+using BlazorDatasheet.DataStructures.Geometry;
+
+namespace BlazorDatasheet.Core.Data;
+
+public class Sheet
+{
+ ///
+ /// The total number of rows in the sheet
+ ///
+ public int NumRows { get; private set; }
+
+ ///
+ /// The total of columns in the sheet
+ ///
+ public int NumCols { get; private set; }
+
+ ///
+ /// Start/finish edits.
+ ///
+ public Editor Editor { get; }
+
+ ///
+ /// Interact with cells & cell data.
+ ///
+ public CellStore Cells { get; }
+
+ ///
+ /// Managers commands & undo/redo. Default is true.
+ ///
+ public CommandManager Commands { get; }
+
+ ///
+ /// Manages sheet formula
+ ///
+ public FormulaEngine.FormulaEngine FormulaEngine { get; }
+
+ ///
+ /// The bounds of the sheet
+ ///
+ public Region Region => new Region(0, NumRows - 1, 0, NumCols - 1);
+
+ ///
+ /// Provides functions for managing the sheet's conditional formatting
+ ///
+ public ConditionalFormatManager ConditionalFormats { get; }
+
+ ///
+ /// Manages and holds information on cell validators.
+ ///
+ public ValidationManager Validators { get; }
+
+ ///
+ /// Contains data, including width, on each column.
+ ///
+ public ColumnInfoStore Columns { get; private set; }
+
+ ///
+ /// Contains data, including height, on each row.
+ ///
+ public RowInfoStore Rows { get; private set; }
+
+ ///
+ /// The sheet's active selection
+ ///
+ public Selection Selection { get; }
+
+ internal IDialogService? Dialog { get; private set; }
+
+ #region EVENTS
+
+ ///
+ /// Fired when a portion of the sheet is marked as dirty.
+ ///
+ public event EventHandler? SheetDirty;
+
+ #endregion
+
+ ///
+ /// True if the sheet is not firing dirty events until is called.
+ ///
+ private bool _isBatchingChanges;
+
+ ///
+ /// If the sheet is batching dirty regions, they are stored here.
+ ///
+ private List _dirtyRegions = new();
+
+ ///
+ /// If the sheet is batching dirty cells, they are stored here.
+ ///
+ private HashSet _dirtyPositions = new();
+
+ private Sheet()
+ {
+ Cells = new Cells.CellStore(this);
+ Commands = new CommandManager(this);
+ Selection = new Selection(this);
+ Editor = new Editor(this);
+ Validators = new ValidationManager(this);
+ Rows = new RowInfoStore(25, this);
+ Columns = new ColumnInfoStore(105, this);
+ FormulaEngine = new FormulaEngine.FormulaEngine(this, Cells);
+ ConditionalFormats = new ConditionalFormatManager(this, Cells, Rows, Columns);
+ }
+
+ public Sheet(int numRows, int numCols) : this()
+ {
+ NumCols = numCols;
+ NumRows = numRows;
+ }
+
+
+ #region COLS
+
+ internal void InsertColAtImpl(int colIndex, int nCols = 1)
+ {
+ NumCols += nCols;
+ }
+
+ ///
+ /// Internal implementation that reduces number of cols and invokes event.
+ ///
+ ///
+ /// Whether the column at index colIndex was removed
+ internal bool RemoveColImpl(int colIndex, int nCols = 1)
+ {
+ NumCols -= nCols;
+ return true;
+ }
+
+ #endregion
+
+ #region ROWS
+
+ ///
+ /// Internal implementation that increases number of rows and invokes event.
+ ///
+ ///
+ /// The number of rows to insert
+ /// The height of each row that is inserted. Default is the default row height
+ ///
+ internal bool InsertRowAtImpl(int rowIndex, int nRows = 1)
+ {
+ NumRows += nRows;
+ return true;
+ }
+
+ internal bool RemoveRowAtImpl(int rowIndex, int nRows)
+ {
+ NumRows -= nRows;
+ return true;
+ }
+
+ #endregion
+
+ ///
+ /// Returns a single cell range at the position row, col
+ ///
+ ///
+ ///
+ ///
+ public SheetRange Range(int row, int col)
+ {
+ return new SheetRange(this, row, col);
+ }
+
+ ///
+ /// Returns a range with the positions specified
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ public SheetRange Range(int rowStart, int rowEnd, int colStart, int colEnd)
+ {
+ return Range(new Region(rowStart, rowEnd, colStart, colEnd));
+ }
+
+ ///
+ /// Returns a new range that contains the region specified
+ ///
+ ///
+ ///
+ public SheetRange Range(IRegion region)
+ {
+ return Range(new List() { region });
+ }
+
+ ///
+ /// The specified by the string e.g A1, B1:B4, A:B, A:A, 2:4, etc.
+ /// Multiple regions can be included by separating them with a ","
+ ///
+ public SheetRange Range(string rangeStr)
+ {
+ return new SheetRange(this, rangeStr);
+ }
+
+ ///
+ /// Returns a column or row range, depending on the axis provided
+ ///
+ /// The axis of the range (row or column)
+ /// The start row/column index
+ /// The end row/column index
+ ///
+ public SheetRange Range(Axis axis, int start, int end)
+ {
+ switch (axis)
+ {
+ case Axis.Col:
+ return Range(new ColumnRegion(start, end));
+ case Axis.Row:
+ return Range(new RowRegion(start, end));
+ }
+
+ throw new Exception("Cannot return a range for axis " + axis);
+ }
+
+ ///
+ /// Returns a new range that contains all the regions specified
+ ///
+ ///
+ ///
+ public SheetRange Range(List regions)
+ {
+ return new SheetRange(this, regions);
+ }
+
+ ///
+ /// Mark the cells specified by positions dirty.
+ ///
+ ///
+ internal void MarkDirty(IEnumerable positions)
+ {
+ if (_isBatchingChanges)
+ {
+ foreach (var position in positions)
+ _dirtyPositions.Add(position);
+ }
+ else
+ SheetDirty?.Invoke(this, new DirtySheetEventArgs()
+ {
+ DirtyPositions = positions.ToHashSet()
+ });
+ }
+
+ ///
+ /// Marks the cell as dirty and requiring re-render
+ ///
+ ///
+ ///
+ internal void MarkDirty(int row, int col)
+ {
+ if (_isBatchingChanges)
+ _dirtyPositions.Add(new CellPosition(row, col));
+ else
+ SheetDirty?.Invoke(this, new DirtySheetEventArgs()
+ {
+ DirtyPositions = new HashSet() { new CellPosition(row, col) }
+ });
+ }
+
+ ///
+ /// Marks the region as dirty and requiring re-render.
+ ///
+ ///
+ internal void MarkDirty(IRegion region)
+ {
+ MarkDirty(new List() { region });
+ }
+
+ ///
+ /// Marks the regions as dirty and requiring re-render.
+ ///
+ ///
+ internal void MarkDirty(IEnumerable regions)
+ {
+ if (_isBatchingChanges)
+ _dirtyRegions.AddRange(regions);
+ else
+ SheetDirty?.Invoke(
+ this, new DirtySheetEventArgs() { DirtyRegions = regions, DirtyPositions = _dirtyPositions });
+ }
+
+ ///
+ /// Batches dirty cell and region additions, as well as cell value changes to emit events once rather
+ /// than every time a cell is dirty or a value is changed.
+ /// Returns false if the sheet was already batching, true otherwise.
+ ///
+ public bool BatchUpdates()
+ {
+ var hasChanged = false;
+ if (!_isBatchingChanges)
+ {
+ _dirtyPositions.Clear();
+ _dirtyRegions.Clear();
+ hasChanged = true;
+ }
+
+ Cells.BatchChanges();
+ _isBatchingChanges = true;
+
+ return hasChanged;
+ }
+
+ ///
+ /// Ends the batching of dirty cells and regions, and emits the dirty sheet event.
+ ///
+ public void EndBatchUpdates()
+ {
+ Cells.EndBatchChanges();
+
+ // Checks for batching changes here, because the cells changed event
+ // may start batching more dirty changes again from subscribers of that event.
+ if (_dirtyRegions.Any() || _dirtyPositions.Any() && _isBatchingChanges)
+ {
+ SheetDirty?.Invoke(this, new DirtySheetEventArgs()
+ {
+ DirtyRegions = _dirtyRegions,
+ DirtyPositions = _dirtyPositions
+ });
+ }
+
+ _isBatchingChanges = false;
+ }
+
+ ///
+ /// Inserts delimited text from the given position
+ /// And assigns cell's values based on the delimited text (tabs and newlines)
+ /// Returns the region of cells that surrounds all cells that are affected
+ ///
+ /// The text to insert
+ /// The position where the insertion starts
+ /// The delimiter that specifies a new-line
+ /// The region of cells that were affected
+ public Region? InsertDelimitedText(string text, CellPosition inputPosition, string newLineDelim = "\n")
+ {
+ if (!Region.Contains(inputPosition))
+ return null;
+
+ if (text.EndsWith('\n'))
+ text = text.Substring(0, text.Length - 1);
+ var lines = text.Split(newLineDelim);
+
+ // We may reach the end of the sheet, so we only need to paste the rows up until the end.
+ var endRow = Math.Min(inputPosition.row + lines.Length - 1, NumRows - 1);
+ // Keep track of the maximum end column that we are inserting into
+ // This is used to determine the region to return.
+ // It is possible that each line is of different cell lengths, so we return the max for all lines
+ var maxEndCol = -1;
+
+ var valChanges = new List<(int row, int col, object value)>();
+
+ int lineNo = 0;
+ for (int row = inputPosition.row; row <= endRow; row++)
+ {
+ var lineSplit = lines[lineNo].Split('\t');
+ // Same thing as above with the number of columns
+ var endCol = Math.Min(inputPosition.col + lineSplit.Length - 1, NumCols - 1);
+
+ maxEndCol = Math.Max(endCol, maxEndCol);
+
+ int cellIndex = 0;
+ for (int col = inputPosition.col; col <= endCol; col++)
+ {
+ valChanges.Add((row, col, lineSplit[cellIndex]));
+ cellIndex++;
+ }
+
+ lineNo++;
+ }
+
+ Cells.SetValues(valChanges);
+
+ return new Region(inputPosition.row, endRow, inputPosition.col, maxEndCol);
+ }
+
+ #region FORMAT
+
+ ///
+ /// Returns the format that is visible at the cell position row, col.
+ /// The order to determine which format is visible is
+ /// 1. Cell format (if it exists)
+ /// 2. Column format
+ /// 3. Row format
+ ///
+ ///
+ ///
+ ///
+ public CellFormat? GetFormat(int row, int col)
+ {
+ var defaultFormat = new CellFormat();
+ var cellFormat = Cells.GetFormat(row, col).Clone();
+ var rowFormat = Rows.RowFormats.Get(row)?.Clone() ?? defaultFormat;
+ var colFormat = Columns.ColFormats.Get(col)?.Clone() ?? defaultFormat;
+
+ rowFormat.Merge(colFormat);
+ rowFormat.Merge(cellFormat);
+ return rowFormat;
+ }
+
+ ///
+ /// Sets the format for a particular range
+ ///
+ ///
+ ///
+ public void SetFormat(SheetRange range, CellFormat cellFormat)
+ {
+ BatchUpdates();
+
+ Commands.BeginCommandGroup();
+ foreach (var region in range.Regions)
+ {
+ var cmd = new SetFormatCommand(region, cellFormat);
+ Commands.ExecuteCommand(cmd);
+ }
+
+ Commands.EndCommandGroup();
+ EndBatchUpdates();
+ }
+
+ #endregion
+
+ public string? GetRegionAsDelimitedText(IRegion inputRegion, char tabDelimiter = '\t', string newLineDelim = "\n")
+ {
+ if (inputRegion.Area == 0)
+ return string.Empty;
+
+ var intersection = inputRegion.GetIntersection(this.Region);
+ if (intersection == null)
+ return null;
+
+ var range = intersection.Copy();
+
+ var strBuilder = new StringBuilder();
+
+ var r0 = range.TopLeft.row;
+ var r1 = range.BottomRight.row;
+ var c0 = range.TopLeft.col;
+ var c1 = range.BottomRight.col;
+
+ for (int row = r0; row <= r1; row++)
+ {
+ for (int col = c0; col <= c1; col++)
+ {
+ var cell = Cells.GetCell(row, col);
+ var value = cell.Value;
+ if (value == null)
+ strBuilder.Append("");
+ else
+ {
+ if (value is string s)
+ {
+ strBuilder.Append(s.Replace(newLineDelim, " ").Replace(tabDelimiter, ' '));
+ }
+ else
+ {
+ strBuilder.Append(value);
+ }
+ }
+
+ if (col != c1)
+ strBuilder.Append(tabDelimiter);
+ }
+
+ strBuilder.Append(newLineDelim);
+ }
+
+ return strBuilder.ToString();
+ }
+
+ public void SetDialogService(IDialogService? service)
+ {
+ Dialog = service;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Data/SheetCell.cs b/src/BlazorDatasheet.Core/Data/SheetCell.cs
new file mode 100644
index 00000000..5d088003
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Data/SheetCell.cs
@@ -0,0 +1,107 @@
+using BlazorDatasheet.Core.Formats;
+using BlazorDatasheet.Core.Interfaces;
+using BlazorDatasheet.Core.Metadata;
+using BlazorDatasheet.DataStructures.Geometry;
+using BlazorDatasheet.Formula.Core;
+
+namespace BlazorDatasheet.Core.Data;
+
+public class SheetCell : IReadOnlyCell
+{
+ public int Row { get; }
+ public int Col { get; }
+ private Sheet _sheet { get; }
+ public bool IsValid => _sheet.Cells.IsValid(Row, Col);
+
+ public SheetCell(int row, int col, Sheet sheet)
+ {
+ Row = row;
+ Col = col;
+ _sheet = sheet;
+ }
+
+ ///
+ /// Returns the Cell's Value and attempts to cast it to T
+ ///
+ ///
+ ///
+ public T GetValue()
+ {
+ return (T)GetValue(typeof(T));
+ }
+
+ ///
+ /// Returns a cell's Value and converts to the type if possible
+ ///
+ ///
+ ///
+ public object? GetValue(Type type)
+ {
+ try
+ {
+ if (Value == null && type == typeof(string))
+ return string.Empty;
+
+ if (this.Value?.GetType() == type)
+ return Value;
+ else
+ {
+ var conversionType = type;
+ if (System.Nullable.GetUnderlyingType(type) != null)
+ {
+ conversionType = System.Nullable.GetUnderlyingType(type);
+ }
+
+ if (conversionType == typeof(string))
+ return Value?.ToString();
+
+ if (Value is IConvertible)
+ return Convert.ChangeType(Value, conversionType);
+
+ return Value;
+ }
+ }
+ catch (Exception e)
+ {
+ return null;
+ }
+ }
+
+ ///
+ /// Gets the merged format at the cell's position. Setting the format will
+ /// merge the format with existing formats in the sheet.
+ ///
+ public CellFormat? Format
+ {
+ get => _sheet.GetFormat(Row, Col);
+ set => _sheet.Cells.MergeFormatImpl(new Region(Row, Col), value);
+ }
+
+ public string Type
+ {
+ get => _sheet.Cells.GetCellType(Row, Col);
+ set => _sheet.Cells.SetCellTypeImpl(new Region(Row, Row, Col, Col), value);
+ }
+
+ public string? Formula
+ {
+ get => _sheet.Cells.GetFormulaString(Row, Col);
+ set => _sheet.Cells.SetFormulaImpl(Row, Col, value);
+ }
+
+ public object? Value
+ {
+ get => _sheet.Cells.GetValue(Row, Col);
+ set => _sheet.Cells.SetValueImpl(Row, Col, value);
+ }
+
+ public object? GetMetaData(string name)
+ {
+ return _sheet.Cells.GetMetaData(Row, Col, name);
+ }
+
+ public void Clear()
+ {
+ _sheet.Cells.ClearCellsImpl(new[] { new Region(Row, Col) });
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Data/SheetRange.cs b/src/BlazorDatasheet.Core/Data/SheetRange.cs
new file mode 100644
index 00000000..334d5442
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Data/SheetRange.cs
@@ -0,0 +1,162 @@
+using BlazorDatasheet.Core.Formats;
+using BlazorDatasheet.Core.Interfaces;
+using BlazorDatasheet.Core.Metadata;
+using BlazorDatasheet.DataStructures.Geometry;
+using BlazorDatasheet.Formula.Core.Interpreter.References;
+
+namespace BlazorDatasheet.Core.Data;
+
+///
+/// Specifies a range, which is a collection of regions in a sheet.
+///
+public class SheetRange
+{
+ internal readonly Sheet Sheet;
+ protected List _regions = new();
+
+ public IReadOnlyList Regions
+ {
+ get => _regions;
+ set => _regions = value.ToList();
+ }
+
+ ///
+ /// Return the positions present in the range. May be non-unique & include empty position
+ /// depending on the regions present.
+ ///
+ public IEnumerable Positions => _rangePositionEnumerator;
+
+ private readonly RangePositionEnumerator _rangePositionEnumerator;
+
+ internal SheetRange(Sheet sheet, List regions)
+ {
+ Sheet = sheet;
+ Regions = regions;
+ _rangePositionEnumerator = new RangePositionEnumerator(this);
+ }
+
+ internal SheetRange(Sheet sheet, int row, int col) : this(sheet, new Region(row, col))
+ {
+ }
+
+ ///
+ /// Create a range with the expression e.g A1, A:B, A1:A5, Allows multiple regions by seperating with a ',' etc.
+ ///
+ ///
+ internal SheetRange(Sheet sheet, string rangeExpression)
+ {
+ Sheet = sheet;
+ _rangePositionEnumerator = new RangePositionEnumerator(this);
+
+ if (string.IsNullOrEmpty(rangeExpression))
+ return;
+
+ foreach (var split in rangeExpression.Split(","))
+ {
+ var region = Region.FromString(split);
+ if (region != null)
+ _regions.Add(region);
+ }
+ }
+
+ internal SheetRange(Sheet sheet, IRegion region) :
+ this(sheet, new List() { region })
+ {
+ }
+
+ ///
+ /// Sets the value of all cells in the range.
+ ///
+ public object? Value
+ {
+ set => doSetValues(value);
+ }
+
+ ///
+ /// Return all non-empty cells (in terms of Value) in this range.
+ ///
+ ///
+ internal IEnumerable GetNonEmptyCells()
+ {
+ return this.GetNonEmptyPositions().Select(x => Sheet.Cells.GetCell(x.row, x.col));
+ }
+
+ ///
+ /// Return all positions of non-empty cells (in terms of Value) in the sheet.
+ ///
+ /// A collection of (row, column) positions of all non-empty cells.
+ internal IEnumerable GetNonEmptyPositions()
+ {
+ return Regions.SelectMany(Sheet.Cells.GetNonEmptyCellPositions);
+ }
+
+ ///
+ /// Sets all the cells in the range to the value specified.
+ ///
+ ///
+ private void doSetValues(object? value)
+ {
+ Sheet.Cells.SetValues(Positions.Select(x => (x.row, x.col, value)).ToList());
+ }
+
+ public void Clear()
+ {
+ Sheet.Cells.ClearCells(this);
+ }
+
+ internal void AddRegion(IRegion region)
+ {
+ _regions.Add(region);
+ }
+
+ internal void RemoveRegion(IRegion region)
+ {
+ _regions.Remove(region);
+ }
+
+ internal SheetRange Clone()
+ {
+ return new SheetRange(this.Sheet, _regions.Select(x => x.Clone()).ToList());
+ }
+
+ ///
+ /// Sets the sheet's selection to this range.
+ ///
+ public void Select()
+ {
+ Sheet.Selection.ClearSelections();
+ Sheet.Selection.Set(this);
+ }
+
+ public void SetMetaData(string name, object? value)
+ {
+ Sheet.BatchUpdates();
+ foreach (var cellPosition in this.Positions)
+ {
+ Sheet.Cells.SetMetaDataImpl(cellPosition.row, cellPosition.col, name, value);
+ }
+
+ Sheet.EndBatchUpdates();
+ }
+
+ ///
+ /// Set the cell type e.g "text", "boolean", "select" on the range.
+ ///
+ public string Type
+ {
+ set => Sheet.Cells.SetType(_regions, value);
+ }
+
+ public CellFormat? Format
+ {
+ set => Sheet.SetFormat(this, value);
+ }
+
+ public void AddValidator(IDataValidator validator)
+ {
+ Sheet.BatchUpdates();
+ foreach (var region in _regions)
+ Sheet.Validators.AddImpl(validator, region);
+ Sheet.EndBatchUpdates();
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet/Edit/CellEditRequest.cs b/src/BlazorDatasheet.Core/Edit/CellEditRequest.cs
similarity index 95%
rename from src/BlazorDatasheet/Edit/CellEditRequest.cs
rename to src/BlazorDatasheet.Core/Edit/CellEditRequest.cs
index 120cc3f8..2ce645c3 100644
--- a/src/BlazorDatasheet/Edit/CellEditRequest.cs
+++ b/src/BlazorDatasheet.Core/Edit/CellEditRequest.cs
@@ -1,4 +1,4 @@
-namespace BlazorDatasheet.Edit;
+namespace BlazorDatasheet.Core.Edit;
///
/// Used when a renderer requests that the cell should begin being edited
diff --git a/src/BlazorDatasheet/Edit/ChangeCellValueRequest.cs b/src/BlazorDatasheet.Core/Edit/ChangeCellValueRequest.cs
similarity index 91%
rename from src/BlazorDatasheet/Edit/ChangeCellValueRequest.cs
rename to src/BlazorDatasheet.Core/Edit/ChangeCellValueRequest.cs
index e375c998..f0f8f1c3 100644
--- a/src/BlazorDatasheet/Edit/ChangeCellValueRequest.cs
+++ b/src/BlazorDatasheet.Core/Edit/ChangeCellValueRequest.cs
@@ -1,4 +1,4 @@
-namespace BlazorDatasheet.Edit;
+namespace BlazorDatasheet.Core.Edit;
///
/// Used when a renderer requests that the cell's value is changed without creating an editor.
diff --git a/src/BlazorDatasheet/Edit/EditEntryMode.cs b/src/BlazorDatasheet.Core/Edit/EditEntryMode.cs
similarity index 86%
rename from src/BlazorDatasheet/Edit/EditEntryMode.cs
rename to src/BlazorDatasheet.Core/Edit/EditEntryMode.cs
index fad3196d..2520e5b1 100644
--- a/src/BlazorDatasheet/Edit/EditEntryMode.cs
+++ b/src/BlazorDatasheet.Core/Edit/EditEntryMode.cs
@@ -1,10 +1,11 @@
-namespace BlazorDatasheet.Edit;
+namespace BlazorDatasheet.Core.Edit;
///
/// The method used to begin/enter the edit.
///
public enum EditEntryMode
{
+ None,
///
/// The user has used the mouse to enter.
///
diff --git a/src/BlazorDatasheet.Core/Edit/Editor.cs b/src/BlazorDatasheet.Core/Edit/Editor.cs
new file mode 100644
index 00000000..2e7cb00f
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Edit/Editor.cs
@@ -0,0 +1,193 @@
+using BlazorDatasheet.Core.Data;
+using BlazorDatasheet.Core.Events.Edit;
+using BlazorDatasheet.Core.Interfaces;
+using BlazorDatasheet.Formula.Core;
+
+namespace BlazorDatasheet.Core.Edit;
+
+public class Editor
+{
+ public Sheet Sheet;
+
+ ///
+ /// Runs before the editor is accepted. Can set whether the edit is successful and whether the editor
+ /// should be cleared.
+ ///
+ public event EventHandler? BeforeEditAccepted;
+
+ ///
+ /// Runs before the editor is opened
+ ///
+ public event EventHandler? BeforeCellEdit;
+
+ ///
+ /// Runs when an edit is accepted.
+ ///
+ public event EventHandler? EditAccepted;
+
+ ///
+ /// Runs when an edit is cancelled
+ ///
+ public event EventHandler? EditCancelled;
+
+ ///
+ /// Runs when an edit has begun.
+ ///
+ public event EventHandler? EditBegin;
+
+ ///
+ /// Calls when the editor value has changed.
+ ///
+ public event EventHandler? EditValueChanged;
+
+ ///
+ /// Called when the edit has finished (canceled, accepted or closed by another means.)
+ ///
+ public event EventHandler EditFinished;
+
+ ///
+ /// If the sheet is editing a value.
+ ///
+ public bool IsEditing { get; private set; }
+
+ private string _editValue;
+
+ ///
+ /// The currently edited value
+ ///
+ public string EditValue
+ {
+ get => _editValue;
+ set
+ {
+ _editValue = value;
+ EditValueChanged?.Invoke(this, _editValue);
+ }
+ }
+
+ public string EditorType { get; private set; }
+
+ ///
+ /// The currently edited cell.
+ ///
+ public IReadOnlyCell? EditCell { get; set; }
+
+ public Editor(Sheet sheet)
+ {
+ Sheet = sheet;
+ }
+
+ public void BeginEdit(int row, int col, bool isSoftEdit = true, EditEntryMode mode = EditEntryMode.None,
+ string? key = null)
+ {
+ if (this.IsEditing)
+ return;
+
+ var cell = Sheet.Cells.GetCell(row, col);
+ var beforeEditArgs = new BeforeCellEditEventArgs(cell, cell.GetValue() ?? string.Empty, cell.Type);
+ this.BeforeCellEdit?.Invoke(this, beforeEditArgs);
+
+ if (beforeEditArgs.CancelEdit)
+ return;
+
+ EditValue = beforeEditArgs.EditValue;
+ IsEditing = true;
+ EditCell = cell;
+ EditorType = beforeEditArgs.EditorType;
+
+ EditBegin?.Invoke(
+ this,
+ new EditBeginEventArgs(cell,
+ beforeEditArgs.EditValue,
+ beforeEditArgs.EditorType,
+ isSoftEdit,
+ mode,
+ key));
+ }
+
+ public bool CancelEdit()
+ {
+ if (this.IsEditing && EditCell != null)
+ {
+ EditCancelled?.Invoke(this, new EditCancelledEventArgs(EditCell.Row, EditCell.Col));
+ EditFinished?.Invoke(this, new EditFinishedEventArgs(EditCell.Row, EditCell.Col));
+ ClearEdit();
+ return true;
+ }
+
+ return false;
+ }
+
+ ///
+ /// Accepts the edit and sets the cell value with a set value command.
+ ///
+ public bool AcceptEdit()
+ {
+ if (!this.IsEditing || EditCell == null)
+ return false;
+
+ // Determine if it's a formula, and calculate.
+ CellFormula? parsedFormula = null;
+ var isFormula = Sheet.FormulaEngine.IsFormula(this.EditValue);
+ var formulaString = isFormula ? this.EditValue : null;
+
+ if (isFormula)
+ {
+ parsedFormula = Sheet.FormulaEngine.ParseFormula(formulaString);
+ if (!parsedFormula.IsValid())
+ {
+ Sheet.Dialog.Alert("Invalid formula");
+ return false;
+ }
+ }
+
+ object? formulaResult = isFormula ? Sheet.FormulaEngine.Evaluate(parsedFormula) : null;
+ var editValue = isFormula ? formulaResult : this.EditValue;
+
+ var beforeAcceptEdit = new BeforeAcceptEditEventArgs(EditCell, editValue, parsedFormula, formulaString);
+ BeforeEditAccepted?.Invoke(this, beforeAcceptEdit);
+
+ if (beforeAcceptEdit.AcceptEdit)
+ {
+ // run the validators that are strict. cancel edit if any fail
+ var validationResult = Sheet.Validators.Validate(editValue, EditCell.Row, EditCell.Col);
+ if (validationResult.IsStrictFail)
+ {
+ Sheet.Dialog.Alert(string.Join("\n", validationResult.FailMessages));
+ return false;
+ }
+
+ EditAccepted?.Invoke(
+ this,
+ new EditAcceptedEventArgs(EditCell.Row, EditCell.Col, beforeAcceptEdit.EditValue,
+ beforeAcceptEdit.Formula, isFormula ? EditValue : null));
+
+
+ if (isFormula && parsedFormula != null)
+ Sheet.Cells.SetFormula(EditCell.Row, EditCell.Col, parsedFormula);
+ else
+ Sheet.Cells.SetValue(EditCell.Row, EditCell.Col, editValue);
+
+ EditFinished?.Invoke(this, new EditFinishedEventArgs(EditCell.Row, EditCell.Col));
+ this.ClearEdit();
+ return true;
+ }
+
+ // Stop the edit even if the edit wasn't accepted
+ if (beforeAcceptEdit.StopEdit)
+ {
+ EditFinished?.Invoke(this, new EditFinishedEventArgs(EditCell.Row, EditCell.Col));
+ this.ClearEdit();
+ }
+
+ return false;
+ }
+
+ private void ClearEdit()
+ {
+ IsEditing = false;
+ EditValue = string.Empty;
+ EditorType = string.Empty;
+ EditCell = null;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet/Events/BeforeCellChangeEventArgs.cs b/src/BlazorDatasheet.Core/Events/BeforeCellChangeEventArgs.cs
similarity index 72%
rename from src/BlazorDatasheet/Events/BeforeCellChangeEventArgs.cs
rename to src/BlazorDatasheet.Core/Events/BeforeCellChangeEventArgs.cs
index 5b2958bc..f1b349a5 100644
--- a/src/BlazorDatasheet/Events/BeforeCellChangeEventArgs.cs
+++ b/src/BlazorDatasheet.Core/Events/BeforeCellChangeEventArgs.cs
@@ -1,7 +1,7 @@
using System.ComponentModel;
-using BlazorDatasheet.Data;
+using BlazorDatasheet.Core.Data;
-namespace BlazorDatasheet.Events;
+namespace BlazorDatasheet.Core.Events;
///
/// Specifies the changes that are to be made to the sheet. If Cancel is set to true, no changes will be made.
@@ -9,7 +9,7 @@ namespace BlazorDatasheet.Events;
///
public class BeforeCellChangeEventArgs : CancelEventArgs
{
- public BeforeCellChangeEventArgs(IEnumerable changes)
+ public BeforeCellChangeEventArgs(IEnumerable changes)
{
Changes = changes;
Cancel = false;
@@ -18,5 +18,5 @@ public BeforeCellChangeEventArgs(IEnumerable changes)
///
/// The list of changes to be made to cells. Modify any individual CellChange when desired to affect the changes.
///
- public IEnumerable Changes { get; }
+ public IEnumerable Changes { get; }
}
\ No newline at end of file
diff --git a/src/BlazorDatasheet/Events/CellMetaDataChangeEventArgs.cs b/src/BlazorDatasheet.Core/Events/CellMetaDataChangeEventArgs.cs
similarity index 91%
rename from src/BlazorDatasheet/Events/CellMetaDataChangeEventArgs.cs
rename to src/BlazorDatasheet.Core/Events/CellMetaDataChangeEventArgs.cs
index 3cb268c4..0f4329b2 100644
--- a/src/BlazorDatasheet/Events/CellMetaDataChangeEventArgs.cs
+++ b/src/BlazorDatasheet.Core/Events/CellMetaDataChangeEventArgs.cs
@@ -1,4 +1,4 @@
-namespace BlazorDatasheet.Events;
+namespace BlazorDatasheet.Core.Events;
public class CellMetaDataChangeEventArgs
{
diff --git a/src/BlazorDatasheet/Events/CellsSelectedEventArgs.cs b/src/BlazorDatasheet.Core/Events/CellsSelectedEventArgs.cs
similarity index 78%
rename from src/BlazorDatasheet/Events/CellsSelectedEventArgs.cs
rename to src/BlazorDatasheet.Core/Events/CellsSelectedEventArgs.cs
index f21b08cc..6cef8533 100644
--- a/src/BlazorDatasheet/Events/CellsSelectedEventArgs.cs
+++ b/src/BlazorDatasheet.Core/Events/CellsSelectedEventArgs.cs
@@ -1,6 +1,6 @@
-using BlazorDatasheet.Interfaces;
+using BlazorDatasheet.Core.Interfaces;
-namespace BlazorDatasheet.Events;
+namespace BlazorDatasheet.Core.Events;
public class CellsSelectedEventArgs
{
diff --git a/src/BlazorDatasheet/Events/ChangeEventArgs.cs b/src/BlazorDatasheet.Core/Events/ChangeEventArgs.cs
similarity index 89%
rename from src/BlazorDatasheet/Events/ChangeEventArgs.cs
rename to src/BlazorDatasheet.Core/Events/ChangeEventArgs.cs
index 381015a7..84127cda 100644
--- a/src/BlazorDatasheet/Events/ChangeEventArgs.cs
+++ b/src/BlazorDatasheet.Core/Events/ChangeEventArgs.cs
@@ -1,4 +1,4 @@
-namespace BlazorDatasheet.Events;
+namespace BlazorDatasheet.Core.Events;
public class ChangeEventArgs
{
diff --git a/src/BlazorDatasheet/Events/ConditionalFormatPreparedEventArgs.cs b/src/BlazorDatasheet.Core/Events/ConditionalFormatPreparedEventArgs.cs
similarity index 78%
rename from src/BlazorDatasheet/Events/ConditionalFormatPreparedEventArgs.cs
rename to src/BlazorDatasheet.Core/Events/ConditionalFormatPreparedEventArgs.cs
index c59e9be9..8ba32969 100644
--- a/src/BlazorDatasheet/Events/ConditionalFormatPreparedEventArgs.cs
+++ b/src/BlazorDatasheet.Core/Events/ConditionalFormatPreparedEventArgs.cs
@@ -1,6 +1,6 @@
-using BlazorDatasheet.Formats;
+using BlazorDatasheet.Core.Formats;
-namespace BlazorDatasheet.Events;
+namespace BlazorDatasheet.Core.Events;
public class ConditionalFormatPreparedEventArgs
{
diff --git a/src/BlazorDatasheet/Events/ConditionalFormatRegionsChangedEventArgs.cs b/src/BlazorDatasheet.Core/Events/ConditionalFormatRegionsChangedEventArgs.cs
similarity index 82%
rename from src/BlazorDatasheet/Events/ConditionalFormatRegionsChangedEventArgs.cs
rename to src/BlazorDatasheet.Core/Events/ConditionalFormatRegionsChangedEventArgs.cs
index 17c33de7..595692fe 100644
--- a/src/BlazorDatasheet/Events/ConditionalFormatRegionsChangedEventArgs.cs
+++ b/src/BlazorDatasheet.Core/Events/ConditionalFormatRegionsChangedEventArgs.cs
@@ -1,6 +1,6 @@
-using BlazorDatasheet.Data;
+using BlazorDatasheet.DataStructures.Geometry;
-namespace BlazorDatasheet.Events;
+namespace BlazorDatasheet.Core.Events;
public class ConditionalFormatRegionsChangedEventArgs
{
diff --git a/src/BlazorDatasheet.Core/Events/Edit/BeforeAcceptEditEventArgs.cs b/src/BlazorDatasheet.Core/Events/Edit/BeforeAcceptEditEventArgs.cs
new file mode 100644
index 00000000..12fb3dfe
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Events/Edit/BeforeAcceptEditEventArgs.cs
@@ -0,0 +1,39 @@
+using BlazorDatasheet.Core.Interfaces;
+using BlazorDatasheet.Formula.Core;
+
+namespace BlazorDatasheet.Core.Events.Edit;
+
+public class BeforeAcceptEditEventArgs
+{
+ public IReadOnlyCell Cell { get; }
+ public object? EditValue { get; }
+ public CellFormula? Formula { get; }
+
+ public string? FormulaString { get; }
+
+ ///
+ /// Determines whether the edit is accepted or not.
+ ///
+ public bool AcceptEdit { get; set; } = true;
+
+ ///
+ /// Determines whether the edit is stopped from continuing.
+ ///
+ public bool StopEdit { get; private set; }
+
+ public BeforeAcceptEditEventArgs(IReadOnlyCell cell, object? editValue, CellFormula? formula, string? formulaString)
+ {
+ Cell = cell;
+ EditValue = editValue;
+ Formula = formula;
+ FormulaString = formulaString;
+ }
+
+ ///
+ /// Stop the edit, even if the edit is not accepted.
+ ///
+ public void StopEditing()
+ {
+ StopEdit = true;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Events/Edit/BeforeCellEditEventArgs.cs b/src/BlazorDatasheet.Core/Events/Edit/BeforeCellEditEventArgs.cs
new file mode 100644
index 00000000..83cba0d4
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Events/Edit/BeforeCellEditEventArgs.cs
@@ -0,0 +1,29 @@
+using BlazorDatasheet.Core.Interfaces;
+
+namespace BlazorDatasheet.Core.Events.Edit;
+
+public class BeforeCellEditEventArgs
+{
+ public IReadOnlyCell Cell { get; }
+
+ ///
+ /// The value that will be passed to the editor. This can be modified before editing starts.
+ ///
+ public string EditValue { get; set; }
+ ///
+ /// The type of editor. This can be modified.
+ ///
+ public string EditorType { get; set; }
+
+ ///
+ /// Whether or not to cancel the edit before it has begun. Set to true to cancel.
+ ///
+ public bool CancelEdit { get; set; } = false;
+
+ public BeforeCellEditEventArgs(IReadOnlyCell cell, string? editValue, string editorType)
+ {
+ Cell = cell;
+ EditValue = editValue;
+ EditorType = editorType;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet/Edit/Events/BeginEditEventArgs.cs b/src/BlazorDatasheet.Core/Events/Edit/BeginEditEventArgs.cs
similarity index 85%
rename from src/BlazorDatasheet/Edit/Events/BeginEditEventArgs.cs
rename to src/BlazorDatasheet.Core/Events/Edit/BeginEditEventArgs.cs
index 2654efdc..0b04611b 100644
--- a/src/BlazorDatasheet/Edit/Events/BeginEditEventArgs.cs
+++ b/src/BlazorDatasheet.Core/Events/Edit/BeginEditEventArgs.cs
@@ -1,4 +1,6 @@
-namespace BlazorDatasheet.Edit.Events;
+using BlazorDatasheet.Core.Edit;
+
+namespace BlazorDatasheet.Core.Events.Edit;
public class BeginEditEventArgs
{
diff --git a/src/BlazorDatasheet.Core/Events/Edit/EditAcceptedEventArgs.cs b/src/BlazorDatasheet.Core/Events/Edit/EditAcceptedEventArgs.cs
new file mode 100644
index 00000000..883809c3
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Events/Edit/EditAcceptedEventArgs.cs
@@ -0,0 +1,22 @@
+using BlazorDatasheet.Formula.Core;
+
+namespace BlazorDatasheet.Core.Events.Edit;
+
+public class EditAcceptedEventArgs
+{
+ public int Row { get; }
+ public int Col { get; }
+ public object? Value { get; }
+
+ public CellFormula? Formula { get; }
+ public string? FormulaString { get; }
+
+ public EditAcceptedEventArgs(int row, int col, object? value, CellFormula? formula, string? formulaString)
+ {
+ Row = row;
+ Col = col;
+ Value = value;
+ Formula = formula;
+ FormulaString = formulaString;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Events/Edit/EditBeginEventArgs.cs b/src/BlazorDatasheet.Core/Events/Edit/EditBeginEventArgs.cs
new file mode 100644
index 00000000..54ff2bfb
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Events/Edit/EditBeginEventArgs.cs
@@ -0,0 +1,29 @@
+using BlazorDatasheet.Core.Edit;
+using BlazorDatasheet.Core.Interfaces;
+
+namespace BlazorDatasheet.Core.Events.Edit;
+
+public class EditBeginEventArgs
+{
+ public IReadOnlyCell Cell { get; }
+ public string? EditValue { get; }
+ public string Type { get; }
+ public bool IsSoftEdit { get; }
+ public EditEntryMode Mode { get; }
+ public string? Key { get; }
+
+ public EditBeginEventArgs(IReadOnlyCell cell,
+ string? editValue,
+ string type,
+ bool isSoftEdit,
+ EditEntryMode mode,
+ string? key)
+ {
+ Cell = cell;
+ EditValue = editValue;
+ Type = type;
+ IsSoftEdit = isSoftEdit;
+ Mode = mode;
+ Key = key;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Events/Edit/EditCancelledEventArgs.cs b/src/BlazorDatasheet.Core/Events/Edit/EditCancelledEventArgs.cs
new file mode 100644
index 00000000..f940c9ea
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Events/Edit/EditCancelledEventArgs.cs
@@ -0,0 +1,13 @@
+namespace BlazorDatasheet.Core.Events.Edit;
+
+public class EditCancelledEventArgs
+{
+ public EditCancelledEventArgs(int row, int col)
+ {
+ Row = row;
+ Col = col;
+ }
+
+ public int Row { get; }
+ public int Col { get; }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Events/Edit/EditFinishedEventArgs.cs b/src/BlazorDatasheet.Core/Events/Edit/EditFinishedEventArgs.cs
new file mode 100644
index 00000000..33ecab44
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Events/Edit/EditFinishedEventArgs.cs
@@ -0,0 +1,13 @@
+namespace BlazorDatasheet.Core.Events.Edit;
+
+public class EditFinishedEventArgs
+{
+ public EditFinishedEventArgs(int row, int col)
+ {
+ Row = row;
+ Col = col;
+ }
+
+ public int Row { get; }
+ public int Col { get; }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet/Events/FormatChangedEventArgs.cs b/src/BlazorDatasheet.Core/Events/FormatChangedEventArgs.cs
similarity index 89%
rename from src/BlazorDatasheet/Events/FormatChangedEventArgs.cs
rename to src/BlazorDatasheet.Core/Events/FormatChangedEventArgs.cs
index cf1708e3..bd426889 100644
--- a/src/BlazorDatasheet/Events/FormatChangedEventArgs.cs
+++ b/src/BlazorDatasheet.Core/Events/FormatChangedEventArgs.cs
@@ -1,8 +1,7 @@
-using BlazorDatasheet.Data;
-using BlazorDatasheet.Formats;
-using BlazorDatasheet.Render;
+using BlazorDatasheet.Core.Formats;
+using BlazorDatasheet.DataStructures.Geometry;
-namespace BlazorDatasheet.Events;
+namespace BlazorDatasheet.Core.Events;
public class FormatChangedEventArgs
{
diff --git a/src/BlazorDatasheet.Core/Events/Formula/CellFormulaChangeEventArgs.cs b/src/BlazorDatasheet.Core/Events/Formula/CellFormulaChangeEventArgs.cs
new file mode 100644
index 00000000..b500b488
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Events/Formula/CellFormulaChangeEventArgs.cs
@@ -0,0 +1,19 @@
+using BlazorDatasheet.Formula.Core;
+
+namespace BlazorDatasheet.Core.Events.Formula;
+
+public class CellFormulaChangeEventArgs
+{
+ public int Row { get; }
+ public int Col { get; }
+ public CellFormula? OldFormula { get; }
+ public CellFormula? NewFormula { get; }
+
+ public CellFormulaChangeEventArgs(int row, int col, CellFormula? oldFormula, CellFormula? newFormula)
+ {
+ Row = row;
+ Col = col;
+ OldFormula = oldFormula;
+ NewFormula = newFormula;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Events/FormulaChangedEventArgs.cs b/src/BlazorDatasheet.Core/Events/FormulaChangedEventArgs.cs
new file mode 100644
index 00000000..1c43cd9f
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Events/FormulaChangedEventArgs.cs
@@ -0,0 +1,17 @@
+namespace BlazorDatasheet.Core.Events;
+
+public class FormulaChangedEventArgs
+{
+ public int Row { get; }
+ public int Col { get; }
+ public string? OldFormula { get; }
+ public string? NewFormula { get; }
+
+ public FormulaChangedEventArgs(int row, int col, string? oldFormula, string? newFormula)
+ {
+ Row = row;
+ Col = col;
+ OldFormula = oldFormula;
+ NewFormula = newFormula;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Events/Layout/ColumnInsertedEventArgs.cs b/src/BlazorDatasheet.Core/Events/Layout/ColumnInsertedEventArgs.cs
new file mode 100644
index 00000000..b8c535b0
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Events/Layout/ColumnInsertedEventArgs.cs
@@ -0,0 +1,13 @@
+namespace BlazorDatasheet.Core.Events.Layout;
+
+public class ColumnInsertedEventArgs
+{
+ public int ColumnIndex { get; }
+ public int NCols { get; }
+
+ public ColumnInsertedEventArgs(int columnIndex, int nCols)
+ {
+ ColumnIndex = columnIndex;
+ NCols = nCols;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Events/Layout/ColumnRemovedEventArgs.cs b/src/BlazorDatasheet.Core/Events/Layout/ColumnRemovedEventArgs.cs
new file mode 100644
index 00000000..4c0fa196
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Events/Layout/ColumnRemovedEventArgs.cs
@@ -0,0 +1,13 @@
+namespace BlazorDatasheet.Core.Events.Layout;
+
+public class ColumnRemovedEventArgs
+{
+ public int ColumnIndex { get; }
+ public int NCols { get; }
+
+ public ColumnRemovedEventArgs(int columnIndex, int nCols)
+ {
+ ColumnIndex = columnIndex;
+ NCols = nCols;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Events/Layout/ColumnWidthChangedEventArgs.cs b/src/BlazorDatasheet.Core/Events/Layout/ColumnWidthChangedEventArgs.cs
new file mode 100644
index 00000000..77862849
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Events/Layout/ColumnWidthChangedEventArgs.cs
@@ -0,0 +1,15 @@
+namespace BlazorDatasheet.Core.Events.Layout;
+
+public class ColumnWidthChangedEventArgs
+{
+ public ColumnWidthChangedEventArgs(int colStart, int colEnd, double newWidth)
+ {
+ ColStart = colStart;
+ NewWidth = newWidth;
+ ColEnd = colEnd;
+ }
+
+ public int ColStart { get; }
+ public double NewWidth { get; }
+ public int ColEnd { get; }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Events/Layout/RowHeightChangedEventArgs.cs b/src/BlazorDatasheet.Core/Events/Layout/RowHeightChangedEventArgs.cs
new file mode 100644
index 00000000..32614fe4
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Events/Layout/RowHeightChangedEventArgs.cs
@@ -0,0 +1,15 @@
+namespace BlazorDatasheet.Core.Events.Layout;
+
+public class RowHeightChangedEventArgs
+{
+ public int RowIndexStart { get; }
+ public double NewHeight { get; }
+ public double RowIndexEnd { get; }
+
+ public RowHeightChangedEventArgs(int rowIndexStart, double rowIndexEnd, double newHeight)
+ {
+ RowIndexStart = rowIndexStart;
+ NewHeight = newHeight;
+ RowIndexEnd = rowIndexEnd;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Events/Layout/RowInsertedEventArgs.cs b/src/BlazorDatasheet.Core/Events/Layout/RowInsertedEventArgs.cs
new file mode 100644
index 00000000..a365d8f8
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Events/Layout/RowInsertedEventArgs.cs
@@ -0,0 +1,16 @@
+namespace BlazorDatasheet.Core.Events.Layout;
+
+public class RowInsertedEventArgs
+{
+ ///
+ /// The index of the new row
+ public int Index { get; }
+
+ public int NRows { get; }
+
+ public RowInsertedEventArgs(int index, int nRows)
+ {
+ Index = index;
+ NRows = nRows;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Events/Layout/RowRemovedEventArgs.cs b/src/BlazorDatasheet.Core/Events/Layout/RowRemovedEventArgs.cs
new file mode 100644
index 00000000..3e369607
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Events/Layout/RowRemovedEventArgs.cs
@@ -0,0 +1,13 @@
+namespace BlazorDatasheet.Core.Events.Layout;
+
+public class RowRemovedEventArgs
+{
+ public int Index { get; }
+ public int NRows { get; }
+
+ public RowRemovedEventArgs(int index, int nRows)
+ {
+ Index = index;
+ NRows = nRows;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Events/PageMovementEvent.cs b/src/BlazorDatasheet.Core/Events/PageMovementEvent.cs
new file mode 100644
index 00000000..26bd3b47
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Events/PageMovementEvent.cs
@@ -0,0 +1,7 @@
+namespace BlazorDatasheet.Core.Events;
+
+public class PageMovementEvent
+{
+ public double PageX { get; set; }
+ public double PageY { get; set; }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet/Events/PasteEventArgs.cs b/src/BlazorDatasheet.Core/Events/PasteEventArgs.cs
similarity index 63%
rename from src/BlazorDatasheet/Events/PasteEventArgs.cs
rename to src/BlazorDatasheet.Core/Events/PasteEventArgs.cs
index 2af96c72..54f65c1a 100644
--- a/src/BlazorDatasheet/Events/PasteEventArgs.cs
+++ b/src/BlazorDatasheet.Core/Events/PasteEventArgs.cs
@@ -1,4 +1,4 @@
-namespace BlazorDatasheet.Events;
+namespace BlazorDatasheet.Core.Events;
public class PasteEventArgs
{
diff --git a/src/BlazorDatasheet.Core/Events/ScrollEvent.cs b/src/BlazorDatasheet.Core/Events/ScrollEvent.cs
new file mode 100644
index 00000000..2fc35260
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Events/ScrollEvent.cs
@@ -0,0 +1,11 @@
+namespace BlazorDatasheet.Core.Events;
+
+public class ScrollEvent
+{
+ public double ScrollTop { get; set; }
+ public double ScrollHeight { get; set; }
+ public double ScrollWidth { get; set; }
+ public double ScrollLeft { get; set; }
+ public double ContainerHeight { get; set; }
+ public double ContainerWidth { get; set; }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Events/SheetInvalidateEventArgs.cs b/src/BlazorDatasheet.Core/Events/SheetInvalidateEventArgs.cs
new file mode 100644
index 00000000..85861b55
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Events/SheetInvalidateEventArgs.cs
@@ -0,0 +1,13 @@
+using BlazorDatasheet.DataStructures.Geometry;
+
+namespace BlazorDatasheet.Core.Events;
+
+public class SheetInvalidateEventArgs
+{
+ public IReadOnlySet DirtyCells { get; }
+
+ internal SheetInvalidateEventArgs(IReadOnlySet dirtyCells)
+ {
+ DirtyCells = dirtyCells;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Events/Validation/ValidatorChangedEventArgs.cs b/src/BlazorDatasheet.Core/Events/Validation/ValidatorChangedEventArgs.cs
new file mode 100644
index 00000000..2934bef6
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Events/Validation/ValidatorChangedEventArgs.cs
@@ -0,0 +1,19 @@
+using BlazorDatasheet.Core.Interfaces;
+using BlazorDatasheet.DataStructures.Geometry;
+
+namespace BlazorDatasheet.Core.Events.Validation;
+
+public class ValidatorChangedEventArgs
+{
+ public IEnumerable ValidatorsRemoved { get; }
+ public IEnumerable ValidatorsAdded { get; }
+ public IEnumerable RegionsAffected { get; }
+
+ public ValidatorChangedEventArgs(IEnumerable validatorsRemoved,
+ IEnumerable validatorsAdded, IEnumerable regionsAffected)
+ {
+ ValidatorsRemoved = validatorsRemoved;
+ ValidatorsAdded = validatorsAdded;
+ RegionsAffected = regionsAffected;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Events/Visual/DirtySheetEventArgs.cs b/src/BlazorDatasheet.Core/Events/Visual/DirtySheetEventArgs.cs
new file mode 100644
index 00000000..e13d89e0
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Events/Visual/DirtySheetEventArgs.cs
@@ -0,0 +1,9 @@
+using BlazorDatasheet.DataStructures.Geometry;
+
+namespace BlazorDatasheet.Core.Events.Visual;
+
+public class DirtySheetEventArgs
+{
+ public HashSet? DirtyPositions { get; init; }
+ public IEnumerable? DirtyRegions { get; init; }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Events/Visual/VisualSheetInvalidateArgs.cs b/src/BlazorDatasheet.Core/Events/Visual/VisualSheetInvalidateArgs.cs
new file mode 100644
index 00000000..fc7e1575
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Events/Visual/VisualSheetInvalidateArgs.cs
@@ -0,0 +1,13 @@
+using BlazorDatasheet.DataStructures.Geometry;
+
+namespace BlazorDatasheet.Core.Events.Visual;
+
+public class VisualSheetInvalidateArgs
+{
+ public HashSet DirtyCells { get; }
+
+ public VisualSheetInvalidateArgs(HashSet dirtyCells)
+ {
+ DirtyCells = dirtyCells;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet/Formats/CellFormat.cs b/src/BlazorDatasheet.Core/Formats/CellFormat.cs
similarity index 59%
rename from src/BlazorDatasheet/Formats/CellFormat.cs
rename to src/BlazorDatasheet.Core/Formats/CellFormat.cs
index ff08ebff..051970a4 100644
--- a/src/BlazorDatasheet/Formats/CellFormat.cs
+++ b/src/BlazorDatasheet.Core/Formats/CellFormat.cs
@@ -1,35 +1,45 @@
using BlazorDatasheet.DataStructures.Intervals;
-using Microsoft.AspNetCore.Components;
+using BlazorDatasheet.Formula.Core;
-namespace BlazorDatasheet.Formats;
+namespace BlazorDatasheet.Core.Formats;
-public class CellFormat : IMergeable
+public class CellFormat : IMergeable, IEquatable
{
///
/// CSS font-weight
///
public string? FontWeight { get; set; }
+
///
/// CSS background color
///
public string? BackgroundColor { get; set; }
+
///
/// CSS color
///
public string? ForegroundColor { get; set; }
+
///
/// How to format the string when rendered.
///
public string? StringFormat { get; set; }
+
///
- /// The icon displayed inside the cell
+ /// The name of displayed inside the cell
///
- public RenderFragment? Icon { get; set; }
+ public string? Icon { get; set; }
+
///
/// The icon's CSS color
///
public string? IconColor { get; set; }
+ ///
+ /// Whether the cell's value can be modified by the user.
+ ///
+ public bool? IsReadOnly { get; set; }
+
///
/// CSS text align
@@ -50,7 +60,8 @@ public CellFormat Clone()
Icon = Icon,
StringFormat = StringFormat,
IconColor = IconColor,
- TextAlign = TextAlign
+ TextAlign = TextAlign,
+ IsReadOnly = IsReadOnly
};
}
@@ -63,19 +74,33 @@ public void Merge(CellFormat? format)
{
if (format == null)
return;
- if (!String.IsNullOrEmpty(format.BackgroundColor))
+ if (!string.IsNullOrEmpty(format.BackgroundColor))
this.BackgroundColor = format.BackgroundColor;
- if (!String.IsNullOrEmpty(format.ForegroundColor))
+ if (!string.IsNullOrEmpty(format.ForegroundColor))
this.ForegroundColor = format.ForegroundColor;
- if (!String.IsNullOrEmpty(format.BackgroundColor))
+ if (!string.IsNullOrEmpty(format.FontWeight))
this.FontWeight = format.FontWeight;
- if (!String.IsNullOrEmpty(format.TextAlign))
+ if (!string.IsNullOrEmpty(format.TextAlign))
this.TextAlign = format.TextAlign;
if (format.Icon != null)
this.Icon = format.Icon;
- if (!String.IsNullOrEmpty(format.StringFormat))
+ if (!string.IsNullOrEmpty(format.StringFormat))
this.StringFormat = format.StringFormat;
- if (!String.IsNullOrEmpty(format.IconColor))
+ if (!string.IsNullOrEmpty(format.IconColor))
this.IconColor = format.IconColor;
+ if (format.IsReadOnly.HasValue)
+ this.IsReadOnly = format.IsReadOnly;
+ }
+
+ public bool Equals(CellFormat? other)
+ {
+ return this.FontWeight == other?.FontWeight &&
+ this.BackgroundColor == other?.BackgroundColor &&
+ this.IconColor == other?.IconColor &&
+ this.IsReadOnly == other?.IsReadOnly &&
+ this.ForegroundColor == other?.ForegroundColor &&
+ this.StringFormat == other?.StringFormat &&
+ this.TextAlign == other?.TextAlign &&
+ this.Icon == other?.Icon;
}
}
\ No newline at end of file
diff --git a/src/BlazorDatasheet/Formats/ConditionalFormat.cs b/src/BlazorDatasheet.Core/Formats/ConditionalFormat.cs
similarity index 85%
rename from src/BlazorDatasheet/Formats/ConditionalFormat.cs
rename to src/BlazorDatasheet.Core/Formats/ConditionalFormat.cs
index b142bcea..4c80b629 100644
--- a/src/BlazorDatasheet/Formats/ConditionalFormat.cs
+++ b/src/BlazorDatasheet.Core/Formats/ConditionalFormat.cs
@@ -1,8 +1,8 @@
-using BlazorDatasheet.Data;
-using BlazorDatasheet.Interfaces;
-using BlazorDatasheet.Render;
+using BlazorDatasheet.Core.Data;
+using BlazorDatasheet.Core.Interfaces;
+using BlazorDatasheet.DataStructures.Geometry;
-namespace BlazorDatasheet.Formats;
+namespace BlazorDatasheet.Core.Formats;
public class ConditionalFormat : ConditionalFormatAbstractBase
{
@@ -10,7 +10,7 @@ public class ConditionalFormat : ConditionalFormatAbstractBase
/// The function that returns the conditional format, based on the cell's value
/// and all other cell values in the sheet
///
- public Func, CellFormat>? FormatFuncDependent { get; private set; }
+ public Func, CellFormat>? FormatFuncDependent { get; }
///
/// The function that returns the conditional format, based only on one cell's value
@@ -29,7 +29,7 @@ private ConditionalFormat()
/// The rule determining whether the conditional format is applied
/// The function determining the actual format to apply, based on both the single cell's
/// value and all cells that the conditional format applies to.
- public ConditionalFormat(Func<(int row, int col), Sheet, bool> rule,
+ public ConditionalFormat(Func rule,
Func, CellFormat> formatFuncDependent)
: this()
{
@@ -46,7 +46,7 @@ public ConditionalFormat(Func<(int row, int col), Sheet, bool> rule,
/// The rule determining whether the conditional format is applied
/// The function determining the actual format to apply, based on both the single cell's
/// value and all cells that the conditional format applies to.
- public ConditionalFormat(Func<(int row, int col), Sheet, bool> rule, Func formatFunc) : this()
+ public ConditionalFormat(Func rule, Func formatFunc) : this()
{
this.Predicate = rule;
FormatFunc = formatFunc;
@@ -61,7 +61,7 @@ public override void Prepare(Sheet sheet)
public override CellFormat? CalculateFormat(int row, int col, Sheet sheet)
{
- var cell = sheet.GetCell(row, col);
+ var cell = sheet.Cells.GetCell(row, col);
if (IsShared)
{
var cells = cellCache;
diff --git a/src/BlazorDatasheet/Formats/ConditionalFormatAbstractBase.cs b/src/BlazorDatasheet.Core/Formats/ConditionalFormatAbstractBase.cs
similarity index 89%
rename from src/BlazorDatasheet/Formats/ConditionalFormatAbstractBase.cs
rename to src/BlazorDatasheet.Core/Formats/ConditionalFormatAbstractBase.cs
index 70455e62..5b6aa58e 100644
--- a/src/BlazorDatasheet/Formats/ConditionalFormatAbstractBase.cs
+++ b/src/BlazorDatasheet.Core/Formats/ConditionalFormatAbstractBase.cs
@@ -1,11 +1,11 @@
-using BlazorDatasheet.Data;
-using BlazorDatasheet.Events;
-using BlazorDatasheet.Interfaces;
-using BlazorDatasheet.Render;
+using BlazorDatasheet.Core.Data;
+using BlazorDatasheet.Core.Events;
+using BlazorDatasheet.Core.Interfaces;
+using BlazorDatasheet.DataStructures.Geometry;
-namespace BlazorDatasheet.Formats;
+namespace BlazorDatasheet.Core.Formats;
-public abstract class ConditionalFormatAbstractBase
+public abstract class ConditionalFormatAbstractBase : IEquatable
{
///
/// The order that the conditional format should be applied.
@@ -15,7 +15,7 @@ public abstract class ConditionalFormatAbstractBase
///
/// List of ranges that the format includes
///
- internal readonly List Ranges = new();
+ internal readonly List Ranges = new();
///
/// Set true if, when one cell value is recalculated, the conditional format should be re-evaluated for all cells
@@ -26,7 +26,7 @@ public abstract class ConditionalFormatAbstractBase
///
/// Whether the conditional format is True and should be run/applied.
///
- public Func<(int row, int col), Sheet, bool>? Predicate { get; protected set; }
+ public Func? Predicate { get; protected set; }
///
/// Whether the conditional formats after this should not be applied if this is true.
@@ -36,7 +36,7 @@ public abstract class ConditionalFormatAbstractBase
///
/// Set of cell positions in this format
///
- internal HashSet<(int row, int col)> Positions { get; private set; } = new();
+ internal HashSet Positions { get; } = new();
public event EventHandler RegionsChanged;
@@ -45,7 +45,7 @@ public abstract class ConditionalFormatAbstractBase
///
///
///
- public IEnumerable<(int row, int col)> GetPositions(HashSet<(int row, int col)>? restrictedTo = null)
+ public IEnumerable GetPositions(HashSet? restrictedTo = null)
{
if (restrictedTo == null)
return Positions.AsEnumerable();
@@ -55,7 +55,7 @@ public abstract class ConditionalFormatAbstractBase
}
}
- internal void Add(BRange range)
+ internal void Add(SheetRange range)
{
Ranges.Add(range);
foreach (var position in range.Positions)
@@ -190,11 +190,11 @@ public void HandleRemove(int index, Axis axis)
public IEnumerable GetCells(Sheet sheet)
{
- return Positions.Select(x => sheet.GetCell(x.row, x.col));
+ return Positions.Select(x => sheet.Cells.GetCell(x.row, x.col));
}
- internal void Remove(BRange range)
+ internal void Remove(SheetRange range)
{
Ranges.Remove(range);
updatePositions();
@@ -237,4 +237,11 @@ public virtual ConditionalFormatAbstractBase Clone()
{
return (ConditionalFormatAbstractBase)this.MemberwiseClone();
}
+
+ public bool Equals(ConditionalFormatAbstractBase? other)
+ {
+ if (other == null)
+ return false;
+ return other == this;
+ }
}
\ No newline at end of file
diff --git a/src/BlazorDatasheet/Formats/ConditionalFormatManager.cs b/src/BlazorDatasheet.Core/Formats/ConditionalFormatManager.cs
similarity index 75%
rename from src/BlazorDatasheet/Formats/ConditionalFormatManager.cs
rename to src/BlazorDatasheet.Core/Formats/ConditionalFormatManager.cs
index a223cc3a..e20a3414 100644
--- a/src/BlazorDatasheet/Formats/ConditionalFormatManager.cs
+++ b/src/BlazorDatasheet.Core/Formats/ConditionalFormatManager.cs
@@ -1,13 +1,13 @@
-using System.Runtime.CompilerServices;
-using System.Security.AccessControl;
-using BlazorDatasheet.Data;
+using BlazorDatasheet.Core.Data;
+using BlazorDatasheet.Core.Data.Cells;
+using BlazorDatasheet.Core.Events;
+using BlazorDatasheet.Core.Events.Layout;
+using BlazorDatasheet.Core.Interfaces;
+using BlazorDatasheet.DataStructures.Geometry;
using BlazorDatasheet.DataStructures.RTree;
-using BlazorDatasheet.Events;
-using BlazorDatasheet.Interfaces;
-using BlazorDatasheet.Render;
-using BlazorDatasheet.Util;
+using BlazorDatasheet.DataStructures.Util;
-namespace BlazorDatasheet.Formats;
+namespace BlazorDatasheet.Core.Formats;
public class ConditionalFormatManager
{
@@ -19,14 +19,14 @@ public class ConditionalFormatManager
public event EventHandler ConditionalFormatPrepared;
- public ConditionalFormatManager(Sheet sheet)
+ public ConditionalFormatManager(Sheet sheet, CellStore cellStore, RowInfoStore rowInfoStore, ColumnInfoStore columnInfoStore)
{
_sheet = sheet;
- _sheet.CellsChanged += HandleCellsChanged;
- _sheet.RowInserted += HandleRowInserted;
- _sheet.RowRemoved += HandleRowRemoved;
- _sheet.ColumnRemoved += HandleColRemoved;
- _sheet.ColumnInserted += HandleColInserted;
+ cellStore.CellsChanged += HandleCellsChanged;
+ rowInfoStore.RowInserted += HandleRowInserted;
+ rowInfoStore.RowRemoved += HandleRowRemoved;
+ columnInfoStore.ColumnRemoved += HandleColRemoved;
+ columnInfoStore.ColumnInserted += HandleColInserted;
}
private void HandleRowRemoved(object? sender, RowRemovedEventArgs e)
@@ -41,7 +41,7 @@ private void HandleRowInserted(object? sender, RowInsertedEventArgs e)
{
foreach (var cf in _registered)
{
- cf.HandleRowInserted(e.IndexAfter);
+ cf.HandleRowInserted(e.Index);
}
}
@@ -57,7 +57,7 @@ private void HandleColInserted(object? sender, ColumnInsertedEventArgs e)
{
foreach (var cf in _registered)
{
- cf.HandleColInserted(e.ColAfter);
+ cf.HandleColInserted(e.ColumnIndex);
}
}
@@ -65,17 +65,18 @@ private void HandleColInserted(object? sender, ColumnInsertedEventArgs e)
/// Applies the conditional format specified by "key" to all cells in a region
///
///
- public void Apply(ConditionalFormatAbstractBase conditionalFormat, IRegion? region)
+ ///
+ public void Apply(IRegion? region, ConditionalFormatAbstractBase conditionalFormat)
{
- Apply(conditionalFormat, new BRange(_sheet, region));
+ Apply(new SheetRange(_sheet, region), conditionalFormat);
}
///
/// Applies the conditional format to the region
///
- ///
///
- public void Apply(ConditionalFormatAbstractBase conditionalFormat, BRange? range)
+ ///
+ public void Apply(SheetRange? range, ConditionalFormatAbstractBase conditionalFormat)
{
if (range == null)
return;
@@ -108,22 +109,13 @@ private void ConditionalFormatOnRegionsChanged(object? sender, ConditionalFormat
_cfTree.BulkLoad(e.RegionsAdded.Select(x => new ConditionalFormatSpatialData(cf, x)));
}
- ///
- /// Applies conditional format to the whole sheet
- ///
- ///
- public void Apply(ConditionalFormatAbstractBase format)
- {
- Apply(format, _sheet.Region);
- }
-
- private void HandleCellsChanged(object? sender, IEnumerable args)
+ private void HandleCellsChanged(object? sender, IEnumerable args)
{
// Simply prepare all cells that the conditional format belongs to (if shared)
var handled = new HashSet();
- foreach (var changeEvent in args)
+ foreach (var arg in args)
{
- var cfs = GetFormatsAppliedToPosition(changeEvent.Row, changeEvent.Col);
+ var cfs = GetFormatsAppliedToPosition(arg.row, arg.col);
foreach (var format in cfs)
{
if (handled.Contains(format.Order))
@@ -140,14 +132,10 @@ private void HandleCellsChanged(object? sender, IEnumerable arg
}
}
- private IEnumerable GetCellsInFormat(ConditionalFormat format)
- {
- return format.Ranges.SelectMany(x => x.GetCells());
- }
-
private IEnumerable GetFormatsAppliedToPosition(int row, int col)
{
- return _cfTree.Search(new Envelope(col, row, col, row))
+ var region = new Region(row, col);
+ return _cfTree.Search(region.ToEnvelope())
.Select(x => x.ConditionalFormat);
}
@@ -159,7 +147,7 @@ private IEnumerable GetFormatsAppliedToPosition(i
///
public void Apply(ConditionalFormatAbstractBase format, int row, int col)
{
- Apply(format, new Region(row, col));
+ Apply(new Region(row, col), format);
}
///
@@ -176,7 +164,7 @@ public void Apply(ConditionalFormatAbstractBase format, int row, int col)
CellFormat? initialFormat = null;
foreach (var format in cfs)
{
- var apply = format.Predicate?.Invoke((row, col), _sheet);
+ var apply = format.Predicate?.Invoke(new CellPosition(row, col), _sheet);
if (apply == false)
continue;
var calced = format.CalculateFormat(row, col, _sheet);
@@ -200,8 +188,7 @@ internal class ConditionalFormatSpatialData : ISpatialData
internal ConditionalFormatSpatialData(ConditionalFormatAbstractBase cf, IRegion region)
{
- _envelope = new Envelope(region.Left, region.Top, region.Right,
- region.Bottom);
+ _envelope = region.ToEnvelope();
_conditionalFormat = cf;
}
}
diff --git a/src/BlazorDatasheet/Formats/DefaultConditionalFormats/DataExpressionConditionalFormat.cs b/src/BlazorDatasheet.Core/Formats/DefaultConditionalFormats/DataExpressionConditionalFormat.cs
similarity index 87%
rename from src/BlazorDatasheet/Formats/DefaultConditionalFormats/DataExpressionConditionalFormat.cs
rename to src/BlazorDatasheet.Core/Formats/DefaultConditionalFormats/DataExpressionConditionalFormat.cs
index 0c1eb961..4edcd9ad 100644
--- a/src/BlazorDatasheet/Formats/DefaultConditionalFormats/DataExpressionConditionalFormat.cs
+++ b/src/BlazorDatasheet.Core/Formats/DefaultConditionalFormats/DataExpressionConditionalFormat.cs
@@ -1,7 +1,6 @@
-using BlazorDatasheet.Data;
-using BlazorDatasheet.Render;
+using BlazorDatasheet.Core.Data;
-namespace BlazorDatasheet.Formats.DefaultConditionalFormats;
+namespace BlazorDatasheet.Core.Formats.DefaultConditionalFormats;
///
/// Designed to only be used with the Object Editor, affects the whole row or column
diff --git a/src/BlazorDatasheet.Core/Formats/DefaultConditionalFormats/NumberScaleConditionalFormat.cs b/src/BlazorDatasheet.Core/Formats/DefaultConditionalFormats/NumberScaleConditionalFormat.cs
new file mode 100644
index 00000000..ec397efa
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Formats/DefaultConditionalFormats/NumberScaleConditionalFormat.cs
@@ -0,0 +1,88 @@
+using System.Drawing;
+using BlazorDatasheet.Core.Data;
+using ColorConverter = BlazorDatasheet.Core.Color.ColorConverter;
+
+namespace BlazorDatasheet.Core.Formats.DefaultConditionalFormats;
+
+public class NumberScaleConditionalFormat : ConditionalFormatAbstractBase
+{
+ private readonly System.Drawing.Color _colorStart;
+ private readonly System.Drawing.Color _colorEnd;
+ private string[] _computedLut;
+ private double cachedMean;
+ private double cachedMin;
+ private double cachedMax;
+
+ public NumberScaleConditionalFormat(System.Drawing.Color colorStart, System.Drawing.Color colorEnd)
+ {
+ _colorStart = colorStart;
+ _colorEnd = colorEnd;
+ ComputeLUT(20);
+ this.IsShared = true;
+ }
+
+ private void ComputeLUT(int size)
+ {
+ _computedLut = new string[size];
+ var hsvStart = ColorConverter.RGBToHSV(_colorStart);
+ var hsvEnd = ColorConverter.RGBToHSV(_colorEnd);
+ for (int i = 0; i < size; i++)
+ {
+ (double h, double s, double v) = ColorConverter.HsvInterp(hsvStart, hsvEnd, (i / (double)size));
+ var newColor = ColorConverter.HSVToRGB(h, s, v);
+ _computedLut[i] = $"rgb({newColor.R},{newColor.G},{newColor.B})";
+ }
+
+ Console.WriteLine("Computed LUT");
+ }
+
+ public override void Prepare(Sheet sheet)
+ {
+ var cells = this.GetCells(sheet);
+ double sum = 0;
+ int count = 0;
+ var max = double.MinValue;
+ var min = double.MaxValue;
+
+ foreach (var cell in cells)
+ {
+ var val = cell.GetValue();
+ if (val == null)
+ continue;
+ sum += val.Value;
+ count++;
+ if (val > max)
+ max = val.Value;
+ if (val < min)
+ min = val.Value;
+ }
+
+ cachedMax = max;
+ cachedMean = sum / count;
+ cachedMin = min;
+
+ base.Prepare(sheet);
+ }
+
+ private string GetColourString(double value, double min, double max, double mean)
+ {
+ var size = Math.Abs(max - min);
+ var frac = (value - min) / size;
+ var index = (int)(frac * _computedLut.Length);
+ var color = _computedLut[Math.Min(index, _computedLut.Length - 1)];
+ return color;
+ }
+
+ public override CellFormat? CalculateFormat(int row, int col, Sheet sheet)
+ {
+ var cell = sheet.Cells.GetCell(row, col);
+ var value = cell.GetValue();
+ if (value == null)
+ return null;
+
+ return new CellFormat()
+ {
+ BackgroundColor = GetColourString(value.Value, cachedMin, cachedMax, cachedMean)
+ };
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Formats/RowColFormatRestoreData.cs b/src/BlazorDatasheet.Core/Formats/RowColFormatRestoreData.cs
new file mode 100644
index 00000000..88368580
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Formats/RowColFormatRestoreData.cs
@@ -0,0 +1,12 @@
+using BlazorDatasheet.Core.Data.Cells;
+using BlazorDatasheet.DataStructures.Intervals;
+using BlazorDatasheet.DataStructures.Store;
+
+namespace BlazorDatasheet.Core.Formats;
+
+public class RowColFormatRestoreData
+{
+ internal List CellFormatRestoreData { get; set; } = new();
+ internal List> IntervalsRemoved { get; set; } = new();
+ internal List> IntervalsAdded { get; set; } = new();
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/FormulaEngine/Environment.cs b/src/BlazorDatasheet.Core/FormulaEngine/Environment.cs
new file mode 100644
index 00000000..e1ddf1ed
--- /dev/null
+++ b/src/BlazorDatasheet.Core/FormulaEngine/Environment.cs
@@ -0,0 +1,85 @@
+using BlazorDatasheet.Core.Data;
+using BlazorDatasheet.DataStructures.Geometry;
+using BlazorDatasheet.Formula.Core;
+using BlazorDatasheet.Formula.Core.Interpreter.Functions;
+
+namespace BlazorDatasheet.Core.FormulaEngine;
+
+public class SheetEnvironment : IEnvironment
+{
+ // only one sheet for now...
+ private readonly Sheet _sheet;
+ private readonly Dictionary _variables = new();
+ private readonly Dictionary _functions = new();
+
+ public SheetEnvironment(Sheet sheet)
+ {
+ _sheet = sheet;
+ }
+
+ public bool VariableExists(string name)
+ {
+ return _variables.ContainsKey(name);
+ }
+
+ public object GetVariable(string name)
+ {
+ return _variables[name];
+ }
+
+ public void SetVariable(string name, object value)
+ {
+ if (!_variables.TryAdd(name, value))
+ _variables[name] = value;
+ }
+
+ public bool FunctionExists(string name)
+ {
+ return _functions.ContainsKey(name.ToLower());
+ }
+
+ public CallableFunctionDefinition GetFunctionDefinition(string name)
+ {
+ return _functions[name.ToLower()];
+ }
+
+ public void SetFunction(string name, CallableFunctionDefinition value)
+ {
+ if (!_functions.ContainsKey(name.ToLower()))
+ _functions.Add(name.ToLower(), value);
+ else
+ _functions[name.ToLower()] = value;
+ }
+
+ public object? GetCellValue(int row, int col) => _sheet.Cells.GetValue(row, col);
+
+ public List GetNumbersInRange(RangeAddress rangeAddress)
+ {
+ return GetNumbersInSheetRange(
+ _sheet.Range(rangeAddress.RowStart, rangeAddress.RowEnd, rangeAddress.ColStart, rangeAddress.ColEnd));
+ }
+
+ public List GetNumbersInRange(ColumnAddress rangeAddress)
+ {
+ return GetNumbersInSheetRange(_sheet.Range(Axis.Col, rangeAddress.Start, rangeAddress.End));
+ }
+
+ public List GetNumbersInRange(RowAddress rangeAddress)
+ {
+ return GetNumbersInSheetRange(_sheet.Range(Axis.Row, rangeAddress.Start, rangeAddress.End));
+ }
+
+ private List GetNumbersInSheetRange(SheetRange range)
+ {
+ var nonEmptyCells = range.GetNonEmptyCells();
+ var nums = new List();
+ foreach (var cell in nonEmptyCells)
+ {
+ var val = cell.GetValue();
+ if (val != null)
+ nums.Add(val.Value);
+ }
+
+ return nums;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/FormulaEngine/FormulaEngine.cs b/src/BlazorDatasheet.Core/FormulaEngine/FormulaEngine.cs
new file mode 100644
index 00000000..421f1caa
--- /dev/null
+++ b/src/BlazorDatasheet.Core/FormulaEngine/FormulaEngine.cs
@@ -0,0 +1,261 @@
+using BlazorDatasheet.Core.Data;
+using BlazorDatasheet.Core.Data.Cells;
+using BlazorDatasheet.Core.Events.Edit;
+using BlazorDatasheet.DataStructures.Geometry;
+using BlazorDatasheet.DataStructures.Graph;
+using BlazorDatasheet.DataStructures.Store;
+using BlazorDatasheet.Formula.Core;
+using BlazorDatasheet.Formula.Core.Interpreter.References;
+using BlazorDatashet.Formula.Functions;
+
+namespace BlazorDatasheet.Core.FormulaEngine;
+
+public class FormulaEngine
+{
+ private readonly Sheet _sheet;
+ private readonly CellStore _cells;
+ private SheetEnvironment _environment;
+ private readonly FormulaParser _parser = new();
+ private readonly FormulaEvaluator _evaluator;
+ private readonly DependencyGraph _dependencyGraph;
+
+ ///
+ /// Keeps track of any ranges referenced by formula.
+ /// This should ideally keep track of the formula that reference the range also,
+ /// but for now it's just whether it's referenced or not.
+ ///
+ private RegionDataStore _observedRanges = new();
+
+ public bool IsCalculating { get; private set; }
+
+ public FormulaEngine(Sheet sheet, CellStore cells)
+ {
+ _sheet = sheet;
+ _cells = cells;
+ _sheet.Editor.BeforeCellEdit += SheetOnBeforeCellEdit;
+ _cells.CellsChanged += SheetOnCellsChanged;
+
+ _environment = new SheetEnvironment(sheet);
+ _evaluator = new FormulaEvaluator(_environment);
+ _dependencyGraph = new DependencyGraph();
+
+ RegisterDefaultFunctions();
+ }
+
+ private void SheetOnCellsChanged(object? sender, IEnumerable e)
+ {
+ if (this.IsCalculating)
+ return;
+
+ var cellsReferenced = false;
+ foreach (var cell in e)
+ {
+ if (IsCellReferenced(cell.row, cell.col))
+ {
+ cellsReferenced = true;
+ break;
+ }
+ }
+
+ if (!cellsReferenced)
+ return;
+
+ this.CalculateSheet();
+ }
+
+ private bool IsCellReferenced(int row, int col)
+ {
+ return _dependencyGraph.HasVertex(new CellVertex(row, col).Key) ||
+ _observedRanges.Any(row, col);
+ }
+
+ private void RegisterDefaultFunctions()
+ {
+ _environment.RegisterLogicalFunctions();
+ _environment.RegisterMathFunctions();
+ }
+
+ private void SheetOnBeforeCellEdit(object? sender, BeforeCellEditEventArgs e)
+ {
+ var formula = _sheet.Cells.GetFormulaString(e.Cell.Row, e.Cell.Col);
+ if (formula != null)
+ {
+ e.EditValue = formula;
+ }
+ }
+
+ public void AddToDependencyGraph(int row, int col, CellFormula formula)
+ {
+ var formulaVertex = new CellVertex(row, col);
+ _dependencyGraph.AddVertex(formulaVertex);
+
+ var references = formula.References!;
+ foreach (var reference in references)
+ {
+ var vertex = GetVertex(reference);
+ _dependencyGraph.AddEdge(vertex, formulaVertex);
+ if (reference is RangeReference rangeReference)
+ {
+ _observedRanges.Add(((RegionVertex)vertex).Region, true);
+ var cellVerticesInsideRange = GetCellVerticesInRange(rangeReference);
+ foreach (var cellVertex in cellVerticesInsideRange)
+ {
+ if (cellVertex != formulaVertex)
+ _dependencyGraph.AddEdge(cellVertex, vertex);
+ }
+ }
+ }
+ }
+
+ private IEnumerable GetCellVerticesInRange(RangeReference rangeRef)
+ {
+ var region = ToRegion(rangeRef);
+ if (region == null)
+ return Enumerable.Empty();
+
+ var cellVertices = new List();
+
+ foreach (var vertex in _dependencyGraph.GetAll())
+ {
+ if (vertex is CellVertex cellVertex &&
+ region.Contains(cellVertex.Row, cellVertex.Col))
+ {
+ cellVertices.Add(cellVertex);
+ }
+ }
+
+ return cellVertices;
+ }
+
+ public CellFormula ParseFormula(string formulaString)
+ {
+ return _parser.FromString(formulaString);
+ }
+
+ public object? Evaluate(CellFormula? formula)
+ {
+ if (formula == null)
+ return null;
+ return _evaluator.Evaluate(formula);
+ }
+
+ ///
+ /// Deletes a formula if it exists.
+ ///
+ ///
+ ///
+ public void RemoveFromDependencyGraph(int row, int col)
+ {
+ var vertex = new CellVertex(row, col);
+ var dependent = _dependencyGraph.Prec(vertex);
+ _dependencyGraph.RemoveVertex(vertex);
+
+ foreach (var d in dependent)
+ {
+ if (!_dependencyGraph.IsDependedOn(d))
+ {
+ _dependencyGraph.RemoveVertex(d);
+ }
+
+ if (d is RegionVertex r)
+ {
+ var equalRegions = _observedRanges.GetDataRegions(r.Region)
+ .Where(x => x.Region.Equals(r.Region)).ToList();
+ if (equalRegions.Any())
+ _observedRanges.Delete(equalRegions.First());
+ }
+ }
+ }
+
+ public void CalculateSheet()
+ {
+ if (IsCalculating)
+ return;
+
+ IsCalculating = true;
+ _sheet.BatchUpdates();
+
+ var order =
+ _dependencyGraph
+ .TopologicalSort();
+
+ var changedValuePositions = new List();
+
+ foreach (var vertex in order)
+ {
+ if (vertex is CellVertex cellVertex)
+ {
+ var formula = _sheet.Cells.GetFormula(cellVertex.Row, cellVertex.Col);
+ if (formula != null)
+ {
+ var value = this.Evaluate(formula);
+ _sheet.Cells.SetValueImpl(cellVertex.Row, cellVertex.Col, value);
+ _sheet.MarkDirty(cellVertex.Row, cellVertex.Col);
+ changedValuePositions.Add(new CellPosition(cellVertex.Row, cellVertex.Col));
+ }
+ }
+ }
+
+ _sheet.EndBatchUpdates();
+
+ IsCalculating = false;
+ }
+
+ private Vertex GetVertex(Reference reference)
+ {
+ if (reference is CellReference cellReference)
+ return new CellVertex(cellReference.Row.RowNumber, cellReference.Col.ColNumber);
+ if (reference is NamedReference namedReference)
+ {
+ return new NamedVertex(namedReference.Name);
+ }
+
+ if (reference is RangeReference rangeReference)
+ {
+ var region = ToRegion(rangeReference);
+ if (region != null)
+ {
+ return new RegionVertex(region, rangeReference.ToRefText());
+ }
+ }
+
+ throw new Exception("Could not convert reference to vertex");
+ }
+
+ private IRegion? ToRegion(RangeReference reference)
+ {
+ if (reference.Start is CellReference startCell && reference.End is CellReference endCell)
+ {
+ return new Region(startCell.Row.RowNumber, endCell.Row.RowNumber, startCell.Col.ColNumber,
+ endCell.Col.ColNumber);
+ }
+
+ if (reference.Start is ColReference startCol && reference.End is ColReference endCol)
+ {
+ return new ColumnRegion(startCol.ColNumber, endCol.ColNumber);
+ }
+
+ if (reference.Start is RowReference startRow && reference.End is RowReference endRow)
+ {
+ return new RowRegion(startRow.RowNumber, endRow.RowNumber);
+ }
+
+ return null;
+ }
+
+ ///
+ /// Returns whether a string is a formula - but not necessarily valid.
+ ///
+ ///
+ ///
+ public bool IsFormula(string formula)
+ {
+ return formula.StartsWith('=');
+ }
+
+ public void SetVariable(string varName, object value)
+ {
+ _environment.SetVariable(varName, value);
+ CalculateSheet();
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet/Interfaces/ICellEditor.cs b/src/BlazorDatasheet.Core/Interfaces/ICellEditor.cs
similarity index 56%
rename from src/BlazorDatasheet/Interfaces/ICellEditor.cs
rename to src/BlazorDatasheet.Core/Interfaces/ICellEditor.cs
index f0574e98..e4090e75 100644
--- a/src/BlazorDatasheet/Interfaces/ICellEditor.cs
+++ b/src/BlazorDatasheet.Core/Interfaces/ICellEditor.cs
@@ -1,8 +1,7 @@
-using BlazorDatasheet.Data;
-using BlazorDatasheet.Edit;
-using Microsoft.AspNetCore.Components;
+using BlazorDatasheet.Core.Data;
+using BlazorDatasheet.Core.Edit;
-namespace BlazorDatasheet.Interfaces;
+namespace BlazorDatasheet.Core.Interfaces;
public interface ICellEditor
{
@@ -15,11 +14,9 @@ public interface ICellEditor
/// Call this event when the editor wants to accept edit
///
event EventHandler RequestAcceptEdit;
- void BeforeEdit(IReadOnlyCell cell);
- bool CanAcceptEdit();
- bool CanCancelEdit();
- object? GetValue();
- void BeginEdit(EditEntryMode entryMode, IReadOnlyCell cell, string key);
+
+ void BeforeEdit(IReadOnlyCell cell, Sheet sheet);
+ void BeginEdit(EditEntryMode entryMode, string? editValue, string key);
bool HandleKey(string key, bool ctrlKey, bool shiftKey, bool altKey, bool metaKey);
Task Focus();
}
\ No newline at end of file
diff --git a/src/BlazorDatasheet/Interfaces/IClearable.cs b/src/BlazorDatasheet.Core/Interfaces/IClearable.cs
similarity index 85%
rename from src/BlazorDatasheet/Interfaces/IClearable.cs
rename to src/BlazorDatasheet.Core/Interfaces/IClearable.cs
index 3e53bb06..892a9f52 100644
--- a/src/BlazorDatasheet/Interfaces/IClearable.cs
+++ b/src/BlazorDatasheet.Core/Interfaces/IClearable.cs
@@ -1,4 +1,4 @@
-namespace BlazorDatasheet.Interfaces;
+namespace BlazorDatasheet.Core.Interfaces;
///
/// If a cell's Data implements this, this function will be called when the cell is cleared
diff --git a/src/BlazorDatasheet.Core/Interfaces/IClipboard.cs b/src/BlazorDatasheet.Core/Interfaces/IClipboard.cs
new file mode 100644
index 00000000..726f4d41
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Interfaces/IClipboard.cs
@@ -0,0 +1,9 @@
+using BlazorDatasheet.Core.Data;
+using BlazorDatasheet.DataStructures.Geometry;
+
+namespace BlazorDatasheet.Core.Interfaces;
+
+public interface IClipboard
+{
+ public Task Copy(IRegion region, Sheet sheet);
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet/Interfaces/IDataValidator.cs b/src/BlazorDatasheet.Core/Interfaces/IDataValidator.cs
similarity index 72%
rename from src/BlazorDatasheet/Interfaces/IDataValidator.cs
rename to src/BlazorDatasheet.Core/Interfaces/IDataValidator.cs
index 84477f21..c76fe21d 100644
--- a/src/BlazorDatasheet/Interfaces/IDataValidator.cs
+++ b/src/BlazorDatasheet.Core/Interfaces/IDataValidator.cs
@@ -1,4 +1,4 @@
-namespace BlazorDatasheet.Interfaces;
+namespace BlazorDatasheet.Core.Interfaces;
public interface IDataValidator
{
@@ -15,4 +15,9 @@ public interface IDataValidator
/// Note that setting a cell value programatically doesn't check IsStrict.
///
public bool IsStrict { get; }
+
+ ///
+ /// The validator's message, which assists the user in working out which validation has failed.
+ ///
+ public string Message { get; }
}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Interfaces/IDialogService.cs b/src/BlazorDatasheet.Core/Interfaces/IDialogService.cs
new file mode 100644
index 00000000..53e09909
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Interfaces/IDialogService.cs
@@ -0,0 +1,6 @@
+namespace BlazorDatasheet.Core.Interfaces;
+
+public interface IDialogService
+{
+ public void Alert(string message);
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet/Interfaces/IEditorManager.cs b/src/BlazorDatasheet.Core/Interfaces/IEditorManager.cs
similarity index 95%
rename from src/BlazorDatasheet/Interfaces/IEditorManager.cs
rename to src/BlazorDatasheet.Core/Interfaces/IEditorManager.cs
index dcc79285..befa57b3 100644
--- a/src/BlazorDatasheet/Interfaces/IEditorManager.cs
+++ b/src/BlazorDatasheet.Core/Interfaces/IEditorManager.cs
@@ -1,4 +1,4 @@
-namespace BlazorDatasheet.Interfaces;
+namespace BlazorDatasheet.Core.Interfaces;
public interface IEditorManager
{
diff --git a/src/BlazorDatasheet.Core/Interfaces/IReadOnlyCell.cs b/src/BlazorDatasheet.Core/Interfaces/IReadOnlyCell.cs
new file mode 100644
index 00000000..ee50d1ef
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Interfaces/IReadOnlyCell.cs
@@ -0,0 +1,18 @@
+using BlazorDatasheet.Core.Formats;
+using BlazorDatasheet.Formula.Core;
+
+namespace BlazorDatasheet.Core.Interfaces;
+
+public interface IReadOnlyCell
+{
+ T GetValue();
+ object? GetValue(Type t);
+ public CellFormat Format { get; }
+ public string Type { get; }
+ public int Row { get; }
+ public int Col { get; }
+ public bool IsValid { get; }
+ public string? Formula { get; }
+ public object? Value { get; }
+ object? GetMetaData(string name);
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Interfaces/IWriteableCell.cs b/src/BlazorDatasheet.Core/Interfaces/IWriteableCell.cs
new file mode 100644
index 00000000..082e0d4f
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Interfaces/IWriteableCell.cs
@@ -0,0 +1,12 @@
+using BlazorDatasheet.Core.Formats;
+
+namespace BlazorDatasheet.Core.Interfaces;
+
+public interface IWriteableCell
+{
+ public CellFormat Format { set; }
+ public string Type { set; }
+ public string? Formula { set; }
+ public object? Value { set; }
+ void SetMetaData(string name, object? value);
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Metadata/CellMetadata.cs b/src/BlazorDatasheet.Core/Metadata/CellMetadata.cs
new file mode 100644
index 00000000..da063d38
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Metadata/CellMetadata.cs
@@ -0,0 +1,57 @@
+using BlazorDatasheet.DataStructures.Intervals;
+
+namespace BlazorDatasheet.Core.Metadata;
+
+public class CellMetadata : IMergeable, IEquatable
+{
+ private Dictionary? _data;
+
+ public void Merge(CellMetadata item)
+ {
+ if (item._data == null)
+ return;
+
+ if (_data == null)
+ _data = item._data.ToDictionary(x => x.Key, x => x.Value);
+ else
+ item._data.ToList().ForEach(x => _data[x.Key] = x.Value);
+ }
+
+ public CellMetadata Clone()
+ {
+ return new CellMetadata()
+ {
+ _data = _data?.ToDictionary(x => x.Key, y => y.Value)
+ };
+ }
+
+ public void SetItem(string key, object item)
+ {
+ if (_data == null)
+ _data = new();
+ if (!_data.TryAdd(key, item))
+ _data[key] = item;
+ }
+
+ public object? GetItem(string key)
+ {
+ if (_data != null && _data.TryGetValue(key, out var val))
+ return val;
+ return null;
+ }
+
+ public bool Equals(CellMetadata? other)
+ {
+ if (other == null)
+ return false;
+
+ if (other._data == null && _data == null)
+ return true;
+
+ if (other._data == null || _data == null)
+ return false;
+
+ return _data.OrderBy(x => x.Key)
+ .SequenceEqual(other._data.OrderBy(x => x.Key));
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet/Selecting/Selection.cs b/src/BlazorDatasheet.Core/Selecting/Selection.cs
similarity index 85%
rename from src/BlazorDatasheet/Selecting/Selection.cs
rename to src/BlazorDatasheet.Core/Selecting/Selection.cs
index 5f1e558e..1a5d948c 100644
--- a/src/BlazorDatasheet/Selecting/Selection.cs
+++ b/src/BlazorDatasheet.Core/Selecting/Selection.cs
@@ -1,10 +1,10 @@
-using BlazorDatasheet.Data;
-using BlazorDatasheet.Interfaces;
-using BlazorDatasheet.Util;
+using BlazorDatasheet.Core.Data;
+using BlazorDatasheet.Core.Events;
+using BlazorDatasheet.DataStructures.Geometry;
-namespace BlazorDatasheet.Selecting;
+namespace BlazorDatasheet.Core.Selecting;
-public class Selection : BRange
+public class Selection : SheetRange
{
private Sheet _sheet;
@@ -13,28 +13,28 @@ public class Selection : BRange
///
public IRegion? ActiveRegion { get; private set; }
+ ///
+ /// The position of the cell that is "active" in the selection.
+ /// It is sometimes but not always the same as the input position.
+ ///
+ public CellPosition ActiveCellPosition { get; private set; }
+
///
/// The region that is currently being selected
///
- internal IRegion? SelectingRegion { get; private set; }
+ public IRegion? SelectingRegion { get; private set; }
///
/// The current mode of selecting
///
- private SelectionMode SelectingMode { get; set; }
+ private SelectionMode _selectingMode;
///
/// The position that the selecting process was started at
///
- internal CellPosition SelectingStartPosition { get; private set; }
+ public CellPosition SelectingStartPosition { get; private set; }
- internal bool IsSelecting => SelectingRegion != null;
-
- ///
- /// The position of the cell that is "active" in the selection.
- /// It is sometimes but not always the same as the input position.
- ///
- public CellPosition ActiveCellPosition { get; private set; }
+ public bool IsSelecting => SelectingRegion != null;
///
/// Fired when the current selection changes
@@ -46,6 +46,8 @@ public class Selection : BRange
///
public event EventHandler SelectingChanged;
+ public event EventHandler CellsSelected;
+
public Selection(Sheet sheet) : base(sheet, new List())
{
_sheet = sheet;
@@ -57,7 +59,7 @@ public void BeginSelectingCell(int row, int col)
{
this.SelectingRegion = new Region(row, col);
this.SelectingStartPosition = new CellPosition(row, col);
- this.SelectingMode = SelectionMode.Cell;
+ this._selectingMode = SelectionMode.Cell;
this.SelectingRegion = ExpandRegionOverMerged(SelectingRegion);
emitSelectingChanged();
}
@@ -66,7 +68,7 @@ public void BeginSelectingCol(int col)
{
this.SelectingRegion = new ColumnRegion(col, col);
this.SelectingStartPosition = new CellPosition(0, col);
- this.SelectingMode = SelectionMode.Column;
+ this._selectingMode = SelectionMode.Column;
this.SelectingRegion = ExpandRegionOverMerged(SelectingRegion);
emitSelectingChanged();
}
@@ -75,7 +77,7 @@ public void BeginSelectingRow(int row)
{
this.SelectingRegion = new RowRegion(row, row);
this.SelectingStartPosition = new CellPosition(row, 0);
- this.SelectingMode = SelectionMode.Row;
+ this._selectingMode = SelectionMode.Row;
this.SelectingRegion = ExpandRegionOverMerged(SelectingRegion);
emitSelectingChanged();
}
@@ -85,16 +87,16 @@ public void UpdateSelectingEndPosition(int row, int col)
if (SelectingRegion == null)
return;
- switch (SelectingMode)
+ switch (_selectingMode)
{
case SelectionMode.Column:
- SelectingRegion = new ColumnRegion(SelectingStartPosition.Col, col);
+ SelectingRegion = new ColumnRegion(SelectingStartPosition.col, col);
break;
case SelectionMode.Row:
- SelectingRegion = new RowRegion(SelectingStartPosition.Row, row);
+ SelectingRegion = new RowRegion(SelectingStartPosition.row, row);
break;
case SelectionMode.Cell:
- SelectingRegion = new Region(SelectingStartPosition.Row, row, SelectingStartPosition.Col, col);
+ SelectingRegion = new Region(SelectingStartPosition.row, row, SelectingStartPosition.col, col);
break;
}
@@ -112,9 +114,8 @@ public void EndSelecting()
{
if (SelectingRegion == null)
return;
- this.ActiveCellPosition = new CellPosition(SelectingStartPosition.Row, SelectingStartPosition.Col);
+ this.ActiveCellPosition = new CellPosition(SelectingStartPosition.row, SelectingStartPosition.col);
this.AddRegionToSelections(SelectingRegion);
- SelectingStartPosition = new CellPosition(-1, -1);
SelectingRegion = null;
emitSelectingChanged();
}
@@ -152,7 +153,7 @@ internal void AddRegionToSelections(IRegion region)
///
/// Adds the region to the selection
///
- ///
+ ///
internal void AddRegionsToSelections(IEnumerable regions)
{
_regions.AddRange(regions);
@@ -161,7 +162,7 @@ internal void AddRegionsToSelections(IEnumerable regions)
}
///
- /// Expands the active selection so that it covers any merged cells
+ /// Expands the so that it covers any merged cells
///
private IRegion? ExpandRegionOverMerged(IRegion? region)
{
@@ -177,24 +178,24 @@ internal void AddRegionsToSelections(IEnumerable regions)
if (boundedRegion == null)
return null;
- List mergeOverlaps;
+ List mergeOverlaps;
do
{
- var top = boundedRegion.GetEdge(Edge.Top).ToEnvelope();
- var right = boundedRegion.GetEdge(Edge.Right).ToEnvelope();
- var left = boundedRegion.GetEdge(Edge.Left).ToEnvelope();
- var bottom = boundedRegion.GetEdge(Edge.Bottom).ToEnvelope();
+ var top = boundedRegion.GetEdge(Edge.Top);
+ var right = boundedRegion.GetEdge(Edge.Right);
+ var left = boundedRegion.GetEdge(Edge.Left);
+ var bottom = boundedRegion.GetEdge(Edge.Bottom);
mergeOverlaps =
- Sheet.MergedCells
- .Search(top, right, left, bottom)
- .Where(x => !boundedRegion.Contains(x.Region))
+ Sheet.Cells
+ .GetMerges(new[] { top, right, left, bottom })
+ .Where(x => !boundedRegion.Contains(x))
.ToList();
// Expand bounded selection to cover all the merges
foreach (var merge in mergeOverlaps)
{
- boundedRegion = boundedRegion.GetBoundingRegion(merge.Region);
+ boundedRegion = boundedRegion.GetBoundingRegion(merge);
}
} while (mergeOverlaps.Any());
@@ -205,7 +206,7 @@ internal void AddRegionsToSelections(IEnumerable regions)
/// Removes the region from the selection
///
///
- public void Remove(IRegion region)
+ private void Remove(IRegion region)
{
_regions.Remove(region);
var newActiveRegion = _regions.LastOrDefault();
@@ -223,7 +224,7 @@ public void Remove(IRegion region)
///
///
///
- internal void ExtendTo(int row, int col)
+ public void ExtendTo(int row, int col)
{
ActiveRegion?.ExtendTo(row, col);
emitSelectingChanged();
@@ -251,7 +252,7 @@ public void SetSingle(int row, int col)
SetSingle(new Region(row, col));
}
- public void Set(BRange range)
+ public void Set(SheetRange range)
{
_regions.Clear();
this.EndSelecting();
@@ -297,13 +298,13 @@ public void MoveActivePositionByRow(int rowDir)
return;
// If it's currently inside a merged cell, find where it should next move to
- var merge = Sheet.GetMergedRegionAtPosition(ActiveCellPosition.Row, ActiveCellPosition.Col);
+ var merge = Sheet.Cells.GetMerge(ActiveCellPosition.row, ActiveCellPosition.col);
if (merge != null)
{
// Move multiple rows if the current position is on the edge away
// from the movement direction.
- if (rowDir == 1 && merge.Top == ActiveCellPosition.Row ||
- rowDir == -1 && merge.Bottom == ActiveCellPosition.Row)
+ if (rowDir == 1 && merge.Top == ActiveCellPosition.row ||
+ rowDir == -1 && merge.Bottom == ActiveCellPosition.row)
{
rowDir *= merge.Height;
}
@@ -319,11 +320,11 @@ public void MoveActivePositionByRow(int rowDir)
// We end up with a new region of area 1 (or the size of the merged cell it is not on)
_regions.Clear();
- var offsetPosn = new CellPosition(ActiveCellPosition.Row + rowDir, ActiveCellPosition.Col);
+ var offsetPosn = new CellPosition(ActiveCellPosition.row + rowDir, ActiveCellPosition.col);
offsetPosn = _sheet.Region.GetConstrained(offsetPosn);
- var newRegion = new Region(offsetPosn.Row, offsetPosn.Col);
+ var newRegion = new Region(offsetPosn.row, offsetPosn.col);
newRegion = ExpandRegionOverMerged(newRegion) as Region;
- this.ActiveCellPosition = new CellPosition(offsetPosn.Row, offsetPosn.Col);
+ this.ActiveCellPosition = new CellPosition(offsetPosn.row, offsetPosn.col);
this.AddRegionToSelections(newRegion);
emitSelectionChange();
@@ -332,8 +333,8 @@ public void MoveActivePositionByRow(int rowDir)
// Move the posn and attempt to bring into either the next region
// or the next cell in the region
- var newRow = ActiveCellPosition.Row + rowDir;
- var newCol = ActiveCellPosition.Col;
+ var newRow = ActiveCellPosition.row + rowDir;
+ var newCol = ActiveCellPosition.col;
if (newRow > activeRegionFixed.Bottom)
{
newCol++;
@@ -371,20 +372,20 @@ public void MoveActivePositionByRow(int rowDir)
/// If there's nowhere to go, collapse and move down. Otherwise, move through all regions,
/// setting them as active where appropriate.
///
- ///
+ ///
public void MoveActivePositionByCol(int colDir)
{
if (ActiveRegion == null || colDir == 0)
return;
// If it's currently inside a merged cell, find where it should next move to
- var merge = Sheet.GetMergedRegionAtPosition(ActiveCellPosition.Row, ActiveCellPosition.Col);
+ var merge = Sheet.Cells.GetMerge(ActiveCellPosition.row, ActiveCellPosition.col);
if (merge != null)
{
// Move multiple rows if the current position is on the edge away
// from the movement direction.
- if (colDir == 1 && merge.Left == ActiveCellPosition.Col ||
- colDir == -1 && merge.Right == ActiveCellPosition.Col)
+ if (colDir == 1 && merge.Left == ActiveCellPosition.col ||
+ colDir == -1 && merge.Right == ActiveCellPosition.col)
{
colDir *= merge.Width;
}
@@ -400,11 +401,11 @@ public void MoveActivePositionByCol(int colDir)
// We end up with a new region of area 1 (or the size of the merged cell it is not on)
_regions.Clear();
- var offsetPosn = new CellPosition(ActiveCellPosition.Row, ActiveCellPosition.Col + colDir);
+ var offsetPosn = new CellPosition(ActiveCellPosition.row, ActiveCellPosition.col + colDir);
offsetPosn = _sheet.Region.GetConstrained(offsetPosn);
- var newRegion = new Region(offsetPosn.Row, offsetPosn.Col);
+ var newRegion = new Region(offsetPosn.row, offsetPosn.col);
newRegion = ExpandRegionOverMerged(newRegion) as Region;
- this.ActiveCellPosition = new CellPosition(offsetPosn.Row, offsetPosn.Col);
+ this.ActiveCellPosition = new CellPosition(offsetPosn.row, offsetPosn.col);
this.AddRegionToSelections(newRegion);
emitSelectionChange();
@@ -413,8 +414,8 @@ public void MoveActivePositionByCol(int colDir)
// Move the posn and attempt to bring into either the next region
// or the next cell in the region
- var newRow = ActiveCellPosition.Row;
- var newCol = ActiveCellPosition.Col + colDir;
+ var newRow = ActiveCellPosition.row;
+ var newCol = ActiveCellPosition.col + colDir;
if (newCol > activeRegionFixed.Right)
{
newCol = activeRegionFixed.Left;
@@ -487,6 +488,7 @@ private IRegion getRegionBeforeActive()
private void emitSelectionChange()
{
SelectionChanged?.Invoke(this, _regions);
+ CellsSelected?.Invoke(this, new CellsSelectedEventArgs(_sheet.Cells.GetCellsInRegions(_regions)));
}
///
@@ -495,17 +497,17 @@ private void emitSelectionChange()
///
public CellPosition GetInputPosition()
{
- if (ActiveCellPosition.IsInvalid)
+ if (this.ActiveRegion == null)
throw new Exception("Invalid cell position");
// Check whether there are any merged regions at the ActiveCellPosition.
// If there are, the input position is the top left of the merged,
// Otherwise it corresponds to the active cell position.
- var merged = Sheet.GetMergedRegionAtPosition(ActiveCellPosition.Row, ActiveCellPosition.Col);
+ var merged = Sheet.Cells.GetMerge(ActiveCellPosition.row, ActiveCellPosition.col);
if (merged == null)
return ActiveCellPosition;
else
- return new CellPosition(merged.TopLeft.Row, merged.TopLeft.Col);
+ return new CellPosition(merged.TopLeft.row, merged.TopLeft.col);
}
#endregion
diff --git a/src/BlazorDatasheet/Selecting/SelectionMode.cs b/src/BlazorDatasheet.Core/Selecting/SelectionMode.cs
similarity index 58%
rename from src/BlazorDatasheet/Selecting/SelectionMode.cs
rename to src/BlazorDatasheet.Core/Selecting/SelectionMode.cs
index 710fb772..17b87be6 100644
--- a/src/BlazorDatasheet/Selecting/SelectionMode.cs
+++ b/src/BlazorDatasheet.Core/Selecting/SelectionMode.cs
@@ -1,4 +1,4 @@
-namespace BlazorDatasheet.Selecting;
+namespace BlazorDatasheet.Core.Selecting;
public enum SelectionMode
{
diff --git a/src/BlazorDatasheet/Util/KeyUtil.cs b/src/BlazorDatasheet.Core/Util/KeyUtil.cs
similarity index 93%
rename from src/BlazorDatasheet/Util/KeyUtil.cs
rename to src/BlazorDatasheet.Core/Util/KeyUtil.cs
index 4967737c..f7007034 100644
--- a/src/BlazorDatasheet/Util/KeyUtil.cs
+++ b/src/BlazorDatasheet.Core/Util/KeyUtil.cs
@@ -1,6 +1,6 @@
-namespace BlazorDatasheet.Util;
+namespace BlazorDatasheet.Core.Util;
-public class KeyUtil
+public static class KeyUtil
{
public static bool IsArrowKey(string key)
{
diff --git a/src/BlazorDatasheet/Util/MaxStack.cs b/src/BlazorDatasheet.Core/Util/MaxStack.cs
similarity index 84%
rename from src/BlazorDatasheet/Util/MaxStack.cs
rename to src/BlazorDatasheet.Core/Util/MaxStack.cs
index 48f93fbc..005c3d12 100644
--- a/src/BlazorDatasheet/Util/MaxStack.cs
+++ b/src/BlazorDatasheet.Core/Util/MaxStack.cs
@@ -1,4 +1,4 @@
-namespace BlazorDatasheet.Util;
+namespace BlazorDatasheet.Core.Util;
public class MaxStack
{
@@ -27,7 +27,7 @@ public void Push(T item)
{
if (!_listImpl.Any())
return default(T);
-
+
var topItem = _listImpl.LastOrDefault();
_listImpl.RemoveAt(_listImpl.Count - 1);
return topItem;
@@ -38,6 +38,16 @@ public void Push(T item)
return _listImpl.LastOrDefault();
}
+ public IEnumerable GetAllItems()
+ {
+ return _listImpl;
+ }
+
+ public int Count()
+ {
+ return _listImpl.Count;
+ }
+
public void Clear()
{
_listImpl.Clear();
diff --git a/src/BlazorDatasheet/Util/Properties.cs b/src/BlazorDatasheet.Core/Util/Properties.cs
similarity index 95%
rename from src/BlazorDatasheet/Util/Properties.cs
rename to src/BlazorDatasheet.Core/Util/Properties.cs
index 3f3a95a2..7f160ba8 100644
--- a/src/BlazorDatasheet/Util/Properties.cs
+++ b/src/BlazorDatasheet.Core/Util/Properties.cs
@@ -1,9 +1,9 @@
using System.Linq.Expressions;
using System.Reflection;
-namespace BlazorDatasheet.Util;
+namespace BlazorDatasheet.Core.Util;
-public class Properties
+public static class Properties
{
public static PropertyInfo GetPropertyInfo(
Expression> propertyLambda)
diff --git a/src/BlazorDatasheet/Util/TypeExtensions.cs b/src/BlazorDatasheet.Core/Util/TypeExtensions.cs
similarity index 95%
rename from src/BlazorDatasheet/Util/TypeExtensions.cs
rename to src/BlazorDatasheet.Core/Util/TypeExtensions.cs
index ac47dcf1..871cd7b2 100644
--- a/src/BlazorDatasheet/Util/TypeExtensions.cs
+++ b/src/BlazorDatasheet.Core/Util/TypeExtensions.cs
@@ -1,4 +1,4 @@
-namespace BlazorDatasheet.Util;
+namespace BlazorDatasheet.Core.Util;
public static class TypeExtensions
{
diff --git a/src/BlazorDatasheet/Validation/NumberValidator.cs b/src/BlazorDatasheet.Core/Validation/NumberValidator.cs
similarity index 64%
rename from src/BlazorDatasheet/Validation/NumberValidator.cs
rename to src/BlazorDatasheet.Core/Validation/NumberValidator.cs
index dc9167b9..9a59b186 100644
--- a/src/BlazorDatasheet/Validation/NumberValidator.cs
+++ b/src/BlazorDatasheet.Core/Validation/NumberValidator.cs
@@ -1,6 +1,6 @@
-using BlazorDatasheet.Interfaces;
+using BlazorDatasheet.Core.Interfaces;
-namespace BlazorDatasheet.Validation;
+namespace BlazorDatasheet.Core.Validation;
public class NumberValidator : IDataValidator
{
@@ -17,5 +17,6 @@ public bool IsValid(object? value)
return double.TryParse(val, out double res);
}
- public bool IsStrict { get; private set; }
+ public bool IsStrict { get; }
+ public string Message => "The value must be a valid number.";
}
\ No newline at end of file
diff --git a/src/BlazorDatasheet/Validation/SourceValidator.cs b/src/BlazorDatasheet.Core/Validation/SourceValidator.cs
similarity index 81%
rename from src/BlazorDatasheet/Validation/SourceValidator.cs
rename to src/BlazorDatasheet.Core/Validation/SourceValidator.cs
index 72afa57c..f272c859 100644
--- a/src/BlazorDatasheet/Validation/SourceValidator.cs
+++ b/src/BlazorDatasheet.Core/Validation/SourceValidator.cs
@@ -1,11 +1,12 @@
-using BlazorDatasheet.Interfaces;
+using BlazorDatasheet.Core.Interfaces;
-namespace BlazorDatasheet.Validation;
+namespace BlazorDatasheet.Core.Validation;
public class SourceValidator : IDataValidator
{
public List ValidationSource { get; }
- public bool IsStrict { get; private set; }
+ public bool IsStrict { get; }
+ public string Message => "The value must be one of the source values.";
///
/// Ensures that the value is equal to one of the validation sources
diff --git a/src/BlazorDatasheet.Core/Validation/ValidationManager.cs b/src/BlazorDatasheet.Core/Validation/ValidationManager.cs
new file mode 100644
index 00000000..efac1400
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Validation/ValidationManager.cs
@@ -0,0 +1,176 @@
+using BlazorDatasheet.Core.Commands;
+using BlazorDatasheet.Core.Data;
+using BlazorDatasheet.Core.Events.Validation;
+using BlazorDatasheet.Core.Interfaces;
+using BlazorDatasheet.DataStructures.Geometry;
+using BlazorDatasheet.DataStructures.Store;
+
+namespace BlazorDatasheet.Core.Validation;
+
+public class ValidationManager
+{
+ private readonly Sheet _sheet;
+ internal ConsolidatedDataStore Store { get; } = new();
+ private readonly Dictionary _validators = new();
+
+ public ValidationManager(Sheet sheet)
+ {
+ _sheet = sheet;
+ }
+
+ ///
+ /// Fired when a validator is added or removed from a region(s).
+ ///
+ public event EventHandler ValidatorChanged;
+
+ ///
+ /// Add a to a cell.
+ ///
+ ///
+ ///
+ ///
+ public void Add(int row, int col, IDataValidator validator) =>
+ Add(new Region(row, col), validator);
+
+ ///
+ /// Adds multiple validators to a region.
+ ///
+ ///
+ ///
+ public void Add(IRegion region, IEnumerable validators)
+ {
+ _sheet.Commands.BeginCommandGroup();
+ foreach (var validator in validators)
+ {
+ _sheet.Validators.Add(region, validator);
+ }
+
+ _sheet.Commands.EndCommandGroup();
+ }
+
+ ///
+ /// Add a to a region with the
+ ///
+ ///
+ ///
+ public void Add(IRegion region, IDataValidator validator)
+ {
+ var cmd = new SetValidatorCommand(region, validator);
+ _sheet.Commands.ExecuteCommand(cmd);
+ }
+
+ ///
+ /// Adds the data validator to the region
+ ///
+ ///
+ ///
+ internal void AddImpl(IDataValidator validator, IRegion region)
+ {
+ // if the validator already exists, find the index
+ int? index = GetValidatorIndex(validator);
+
+ if (index == null)
+ {
+ index = _validators.Count;
+ _validators.Add(index.Value, validator);
+ }
+
+ Store.Add(region, index.Value);
+ var args = new ValidatorChangedEventArgs(Array.Empty(),
+ new List() { validator },
+ Array.Empty());
+
+ ValidatorChanged?.Invoke(this, args);
+ }
+
+ ///
+ /// Adds the data validator to a cell position
+ ///
+ ///
+ ///
+ ///
+ internal void AddImpl(IDataValidator validator, int row, int col)
+ {
+ AddImpl(validator, new Region(row, col));
+ }
+
+
+ ///
+ /// Clears the data validator from the region
+ ///
+ ///
+ ///
+ public void Clear(IDataValidator validator, IRegion region)
+ {
+ var index = GetValidatorIndex(validator);
+ if (index == null)
+ return;
+
+ var result = Store.Clear(region, index.Value);
+ var validatorsRemoved = new List();
+
+ if (!Store.GetRegions(index.Value).Any())
+ {
+ validatorsRemoved.Add(_validators[index.Value]);
+ _validators.Remove(index.Value);
+ }
+
+ var args = new ValidatorChangedEventArgs(validatorsRemoved, Array.Empty(),
+ result.regionsRemoved.Concat(result.regionsAdded));
+ ValidatorChanged?.Invoke(this, args);
+ }
+
+ ///
+ /// Returns all data validators for a cell position.
+ ///
+ ///
+ ///
+ ///
+ public IEnumerable Get(int row, int col)
+ {
+ return Store.GetData(row, col)
+ .Where(x => _validators.ContainsKey(x))
+ .Select(x => _validators[x]);
+ }
+
+ ///
+ /// Validates a value against validators defined at a row/column.
+ ///
+ ///
+ ///
+ ///
+ ///
+ public ValidationResult Validate(object? value, int row, int col)
+ {
+ var validators = Get(row, col);
+ bool isStrict = false;
+ bool isValid = true;
+ var failMessages = new List();
+ foreach (var validator in validators)
+ {
+ if (validator.IsValid(value))
+ continue;
+ failMessages.Add(validator.Message);
+ isValid = false;
+ isStrict |= validator.IsStrict;
+ }
+
+ return new ValidationResult(failMessages, isStrict, isValid);
+ }
+
+ ///
+ /// Returns the index of a data validator. Returns null if it doesn't exist.
+ ///
+ ///
+ ///
+ private int? GetValidatorIndex(IDataValidator validator)
+ {
+ foreach (var kp in _validators)
+ {
+ if (kp.Value == validator)
+ return kp.Key;
+ }
+
+ return null;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.Core/Validation/ValidationResult.cs b/src/BlazorDatasheet.Core/Validation/ValidationResult.cs
new file mode 100644
index 00000000..820b3794
--- /dev/null
+++ b/src/BlazorDatasheet.Core/Validation/ValidationResult.cs
@@ -0,0 +1,26 @@
+namespace BlazorDatasheet.Core.Validation;
+
+public struct ValidationResult
+{
+ ///
+ /// Validation messages for validators that resulted in an invalid result, if any.
+ ///
+ public List FailMessages { get; }
+
+ ///
+ /// Whether the fail is "strict" in that it should not allow the value to be set.
+ ///
+ public bool IsStrictFail { get; }
+
+ ///
+ /// Whether the validation is valid after validators have been run.
+ ///
+ public bool IsValid { get; }
+
+ public ValidationResult(List failMessages, bool isStrictFail, bool isValid)
+ {
+ FailMessages = failMessages;
+ IsStrictFail = isStrictFail;
+ IsValid = isValid;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet/Data/AllRegion.cs b/src/BlazorDatasheet.DataStructures/Geometry/AllRegion.cs
similarity index 77%
rename from src/BlazorDatasheet/Data/AllRegion.cs
rename to src/BlazorDatasheet.DataStructures/Geometry/AllRegion.cs
index be4def98..41b3c267 100644
--- a/src/BlazorDatasheet/Data/AllRegion.cs
+++ b/src/BlazorDatasheet.DataStructures/Geometry/AllRegion.cs
@@ -1,4 +1,4 @@
-namespace BlazorDatasheet.Data;
+namespace BlazorDatasheet.DataStructures.Geometry;
///
/// Region that applies to all cells
diff --git a/src/BlazorDatasheet/Data/Axis.cs b/src/BlazorDatasheet.DataStructures/Geometry/Axis.cs
similarity index 75%
rename from src/BlazorDatasheet/Data/Axis.cs
rename to src/BlazorDatasheet.DataStructures/Geometry/Axis.cs
index 7160ba47..84c903f9 100644
--- a/src/BlazorDatasheet/Data/Axis.cs
+++ b/src/BlazorDatasheet.DataStructures/Geometry/Axis.cs
@@ -1,4 +1,4 @@
-namespace BlazorDatasheet.Data;
+namespace BlazorDatasheet.DataStructures.Geometry;
public enum Axis
{
diff --git a/src/BlazorDatasheet.DataStructures/Geometry/CellPosition.cs b/src/BlazorDatasheet.DataStructures/Geometry/CellPosition.cs
new file mode 100644
index 00000000..3a5f0195
--- /dev/null
+++ b/src/BlazorDatasheet.DataStructures/Geometry/CellPosition.cs
@@ -0,0 +1,9 @@
+namespace BlazorDatasheet.DataStructures.Geometry;
+
+public readonly record struct CellPosition(int row, int col)
+{
+ public override string ToString()
+ {
+ return $"({col}, {row})";
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet/Data/ColumnRegion.cs b/src/BlazorDatasheet.DataStructures/Geometry/ColumnRegion.cs
similarity index 78%
rename from src/BlazorDatasheet/Data/ColumnRegion.cs
rename to src/BlazorDatasheet.DataStructures/Geometry/ColumnRegion.cs
index 25f28c39..fcda44f9 100644
--- a/src/BlazorDatasheet/Data/ColumnRegion.cs
+++ b/src/BlazorDatasheet.DataStructures/Geometry/ColumnRegion.cs
@@ -1,6 +1,6 @@
-using BlazorDatasheet.Util;
+using BlazorDatasheet.DataStructures.Util;
-namespace BlazorDatasheet.Data;
+namespace BlazorDatasheet.DataStructures.Geometry;
///
/// A column region. This region does not have an end position.
@@ -22,7 +22,7 @@ public ColumnRegion(int column) : this(column, column)
public override IRegion Copy()
{
- return new ColumnRegion(TopLeft.Col, BottomRight.Col);
+ return new ColumnRegion(TopLeft.col, BottomRight.col);
}
public override void ExtendTo(int row, int col, IRegion? regionLimit = null)
@@ -35,7 +35,7 @@ public override void ExtendTo(int row, int col, IRegion? regionLimit = null)
}
var newColumnEnd = SheetMath
- .ClampInt(regionLimit.TopLeft.Col, regionLimit.BottomRight.Col, col);
+ .ClampInt(regionLimit.TopLeft.col, regionLimit.BottomRight.col, col);
End = new CellPosition(int.MaxValue, newColumnEnd);
SetOrderedBounds();
@@ -58,12 +58,12 @@ public override void Expand(Edge edges, int amount)
public override IRegion GetBoundingRegion(IRegion otherRegion)
{
- return new ColumnRegion(Math.Min(otherRegion.TopLeft.Col, this.TopLeft.Col),
- Math.Max(otherRegion.BottomRight.Col, this.BottomRight.Col));
+ return new ColumnRegion(Math.Min(otherRegion.TopLeft.col, this.TopLeft.col),
+ Math.Max(otherRegion.BottomRight.col, this.BottomRight.col));
}
public override IRegion Clone()
{
- return new ColumnRegion(this.Start.Col, this.End.Col);
+ return new ColumnRegion(this.Start.col, this.End.col);
}
}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.DataStructures/Geometry/Direction.cs b/src/BlazorDatasheet.DataStructures/Geometry/Direction.cs
new file mode 100644
index 00000000..bcf748b9
--- /dev/null
+++ b/src/BlazorDatasheet.DataStructures/Geometry/Direction.cs
@@ -0,0 +1,9 @@
+namespace BlazorDatasheet.DataStructures.Geometry;
+
+public enum Direction
+{
+ Up,
+ Right,
+ Down,
+ Left
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet/Data/Edge.cs b/src/BlazorDatasheet.DataStructures/Geometry/Edge.cs
similarity index 66%
rename from src/BlazorDatasheet/Data/Edge.cs
rename to src/BlazorDatasheet.DataStructures/Geometry/Edge.cs
index 94d8b147..18b2a944 100644
--- a/src/BlazorDatasheet/Data/Edge.cs
+++ b/src/BlazorDatasheet.DataStructures/Geometry/Edge.cs
@@ -1,4 +1,4 @@
-namespace BlazorDatasheet.Data;
+namespace BlazorDatasheet.DataStructures.Geometry;
[Flags]
public enum Edge : short
diff --git a/src/BlazorDatasheet/Data/IRegion.cs b/src/BlazorDatasheet.DataStructures/Geometry/IRegion.cs
similarity index 89%
rename from src/BlazorDatasheet/Data/IRegion.cs
rename to src/BlazorDatasheet.DataStructures/Geometry/IRegion.cs
index 7f496498..fe690ea5 100644
--- a/src/BlazorDatasheet/Data/IRegion.cs
+++ b/src/BlazorDatasheet.DataStructures/Geometry/IRegion.cs
@@ -1,6 +1,6 @@
-namespace BlazorDatasheet.Data;
+namespace BlazorDatasheet.DataStructures.Geometry;
-public interface IRegion
+public interface IRegion : IEquatable
{
///
/// Where the region was started
@@ -127,6 +127,7 @@ public interface IRegion
///
/// Break into a number of regions that do not include the given region.
+ /// If there are no intersections, this region is returned.
///
/// The region to break around
///
@@ -134,11 +135,20 @@ public interface IRegion
///
/// Break into a number of regions that do not include the given position.
+ /// If there are no intersections, this region is returned.
///
/// The position to break around
///
public List Break(CellPosition position);
+ ///
+ /// Break into a number of regions that do not include the given region.
+ /// If there are no intersections, this region is returned.
+ ///
+ ///
+ ///
+ List Break(IEnumerable regions);
+
///
/// Returns the region (which will be one cell wide/high) that runs along the specified edge of this region
///
@@ -204,4 +214,12 @@ public interface IRegion
///
///
public void Contract(Edge edges, int amount);
+
+ ///
+ /// Determines whether the cell position is inside this region
+ ///
+ ///
+ ///
+ bool Contains(CellPosition position);
+
}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.DataStructures/Geometry/Point2d.cs b/src/BlazorDatasheet.DataStructures/Geometry/Point2d.cs
new file mode 100644
index 00000000..ee02d0e5
--- /dev/null
+++ b/src/BlazorDatasheet.DataStructures/Geometry/Point2d.cs
@@ -0,0 +1,13 @@
+namespace BlazorDatasheet.DataStructures.Geometry;
+
+public struct Point2d
+{
+ public double X { get; }
+ public double Y { get; }
+
+ public Point2d(double x, double y)
+ {
+ X = x;
+ Y = y;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.DataStructures/Geometry/Rect.cs b/src/BlazorDatasheet.DataStructures/Geometry/Rect.cs
new file mode 100644
index 00000000..a0dd1ab6
--- /dev/null
+++ b/src/BlazorDatasheet.DataStructures/Geometry/Rect.cs
@@ -0,0 +1,17 @@
+namespace BlazorDatasheet.DataStructures.Geometry;
+
+public struct Rect
+{
+ public double Top { get; }
+ public double Left { get; }
+ public double Right { get; }
+ public double Bottom { get; }
+
+ public Rect(double top, double right, double bottom, double left)
+ {
+ Top = top;
+ Left = left;
+ Right = right;
+ Bottom = bottom;
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet/Data/Region.cs b/src/BlazorDatasheet.DataStructures/Geometry/Region.cs
similarity index 58%
rename from src/BlazorDatasheet/Data/Region.cs
rename to src/BlazorDatasheet.DataStructures/Geometry/Region.cs
index 936730d2..4d387499 100644
--- a/src/BlazorDatasheet/Data/Region.cs
+++ b/src/BlazorDatasheet.DataStructures/Geometry/Region.cs
@@ -1,8 +1,7 @@
-using System.Collections;
-using BlazorDatasheet.Interfaces;
-using BlazorDatasheet.Util;
+using BlazorDatasheet.DataStructures.Graph;
+using BlazorDatasheet.DataStructures.Util;
-namespace BlazorDatasheet.Data;
+namespace BlazorDatasheet.DataStructures.Geometry;
///
/// A region that has a specific start/end position
@@ -11,10 +10,10 @@ public class Region : IRegion
{
public CellPosition TopLeft { get; private set; }
public CellPosition BottomRight { get; private set; }
- public int Top => TopLeft.Row;
- public int Left => TopLeft.Col;
- public int Bottom => BottomRight.Row;
- public int Right => BottomRight.Col;
+ public int Top => TopLeft.row;
+ public int Left => TopLeft.col;
+ public int Bottom => BottomRight.row;
+ public int Right => BottomRight.col;
///
/// Where the region was started
@@ -40,6 +39,10 @@ public Region(int row, int col) : this(row, row, col, col)
{
}
+ public Region(CellPosition position) : this(position.row, position.col)
+ {
+ }
+
///
/// A rectangular region specified by start/end rows & cols
///
@@ -63,10 +66,10 @@ public Region(CellPosition start, CellPosition end)
protected void SetOrderedBounds()
{
- var r0 = Math.Min(Start.Row, End.Row);
- var r1 = Math.Max(Start.Row, End.Row);
- var c0 = Math.Min(Start.Col, End.Col);
- var c1 = Math.Max(Start.Col, End.Col);
+ var r0 = Math.Min(Start.row, End.row);
+ var r1 = Math.Max(Start.row, End.row);
+ var c0 = Math.Min(Start.col, End.col);
+ var c1 = Math.Max(Start.col, End.col);
TopLeft = new CellPosition(r0, c0);
BottomRight = new CellPosition(r1, c1);
@@ -80,10 +83,10 @@ protected void SetOrderedBounds()
///
public bool Contains(int row, int col)
{
- return row >= TopLeft.Row &&
- row <= BottomRight.Row &&
- col >= TopLeft.Col &&
- col <= BottomRight.Col;
+ return row >= TopLeft.row &&
+ row <= BottomRight.row &&
+ col >= TopLeft.col &&
+ col <= BottomRight.col;
}
///
@@ -93,10 +96,20 @@ public bool Contains(int row, int col)
///
public bool Contains(IRegion region)
{
- return region.Start.Col >= Start.Col &&
- region.End.Col <= End.Col &&
- region.Start.Row >= Start.Row &&
- region.End.Row <= End.Row;
+ return region.Left >= Left &&
+ region.Right <= Right &&
+ region.Top >= Top &&
+ region.Bottom <= Bottom;
+ }
+
+ ///
+ /// Determines whether the cell position is inside this region
+ ///
+ ///
+ ///
+ public bool Contains(CellPosition position)
+ {
+ return Contains(position.row, position.col);
}
///
@@ -106,7 +119,7 @@ public bool Contains(IRegion region)
///
public bool SpansCol(int col)
{
- return col >= TopLeft.Col && col <= BottomRight.Col;
+ return col >= TopLeft.col && col <= BottomRight.col;
}
///
@@ -116,8 +129,8 @@ public bool SpansCol(int col)
///
public bool SpansRow(int row)
{
- return row >= TopLeft.Row &&
- row <= BottomRight.Row;
+ return row >= TopLeft.row &&
+ row <= BottomRight.row;
}
public bool Spans(int index, Axis axis)
@@ -131,7 +144,7 @@ public bool Spans(int index, Axis axis)
public IRegion Collapse()
{
- return new Region(TopLeft.Row, TopLeft.Col);
+ return new Region(TopLeft.row, TopLeft.col);
}
///
@@ -144,13 +157,13 @@ public IRegion GetEdge(Edge edge)
switch (edge)
{
case Edge.Top:
- return new Region(this.Start.Row, this.Start.Row, this.Start.Col, this.End.Col);
+ return new Region(this.Start.row, this.Start.row, this.Start.col, this.End.col);
case Edge.Bottom:
- return new Region(this.End.Row, this.End.Row, this.Start.Col, this.End.Col);
+ return new Region(this.End.row, this.End.row, this.Start.col, this.End.col);
case Edge.Left:
- return new Region(this.Start.Row, this.End.Row, this.Start.Col, this.Start.Col);
+ return new Region(this.Start.row, this.End.row, this.Start.col, this.Start.col);
case Edge.Right:
- return new Region(this.Start.Row, this.End.Row, this.End.Col, this.End.Col);
+ return new Region(this.Start.row, this.End.row, this.End.col, this.End.col);
}
return default;
@@ -162,7 +175,7 @@ public IRegion GetEdge(Edge edge)
///
public void Constrain(IRegion? region)
{
- Constrain(region.TopLeft.Row, region.BottomRight.Row, region.TopLeft.Col, region.BottomRight.Col);
+ Constrain(region.TopLeft.row, region.BottomRight.row, region.TopLeft.col, region.BottomRight.col);
}
///
@@ -174,10 +187,10 @@ public void Constrain(IRegion? region)
///
public void Constrain(int otherRowStart, int otherRowEnd, int otherColStart, int otherColEnd)
{
- var r0 = SheetMath.ClampInt(otherRowStart, otherRowEnd, this.TopLeft.Row);
- var r1 = SheetMath.ClampInt(otherRowStart, otherRowEnd, this.BottomRight.Row);
- var c0 = SheetMath.ClampInt(otherColStart, otherColEnd, this.TopLeft.Col);
- var c1 = SheetMath.ClampInt(otherColStart, otherColEnd, this.BottomRight.Col);
+ var r0 = SheetMath.ClampInt(otherRowStart, otherRowEnd, this.TopLeft.row);
+ var r1 = SheetMath.ClampInt(otherRowStart, otherRowEnd, this.BottomRight.row);
+ var c0 = SheetMath.ClampInt(otherColStart, otherColEnd, this.TopLeft.col);
+ var c1 = SheetMath.ClampInt(otherColStart, otherColEnd, this.BottomRight.col);
this.Start = new CellPosition(r0, c0);
this.End = new CellPosition(r1, c1);
SetOrderedBounds();
@@ -189,7 +202,7 @@ public void Constrain(int otherRowStart, int otherRowEnd, int otherColStart, int
///
public virtual IRegion Copy()
{
- return new Region(TopLeft.Row, BottomRight.Row, TopLeft.Col, BottomRight.Col);
+ return new Region(TopLeft.row, BottomRight.row, TopLeft.col, BottomRight.col);
}
///
@@ -198,7 +211,7 @@ public virtual IRegion Copy()
///
public virtual IRegion Clone()
{
- return new Region(this.Start.Row, this.End.Row, this.Start.Col, this.End.Col);
+ return new Region(this.Start.row, this.End.row, this.Start.col, this.End.col);
}
public int GetSize(Axis axis)
@@ -218,8 +231,8 @@ public int GetTrailingEdgeOffset(Axis axis)
public CellPosition GetConstrained(CellPosition cellPosition)
{
- var r = cellPosition.Row;
- var c = cellPosition.Col;
+ var r = cellPosition.row;
+ var c = cellPosition.col;
var r0 = GetLeadingEdgeOffset(Axis.Row);
var r1 = GetTrailingEdgeOffset(Axis.Row);
var c0 = GetLeadingEdgeOffset(Axis.Col);
@@ -242,8 +255,8 @@ public CellPosition GetConstrained(CellPosition cellPosition)
///
public virtual void Shift(int dRow, int dCol)
{
- this.Start = new CellPosition(this.Start.Row + dRow, this.Start.Col + dCol);
- this.End = new CellPosition(this.End.Row + dRow, this.End.Col + dCol);
+ this.Start = new CellPosition(this.Start.row + dRow, this.Start.col + dCol);
+ this.End = new CellPosition(this.End.row + dRow, this.End.col + dCol);
this.SetOrderedBounds();
}
@@ -254,10 +267,10 @@ public virtual void Shift(int dRow, int dCol)
///
public virtual void Expand(Edge edges, int amount)
{
- var endCol = this.End.Col;
- var endRow = this.End.Row;
- var startCol = this.Start.Col;
- var startRow = this.Start.Row;
+ var endCol = this.End.col;
+ var endRow = this.End.row;
+ var startCol = this.Start.col;
+ var startRow = this.Start.row;
if ((edges & Edge.Bottom) == Edge.Bottom)
{
// The order here is deliberate.
@@ -314,30 +327,30 @@ public virtual void Expand(Edge edges, int amount)
public virtual IRegion GetBoundingRegion(IRegion otherRegion)
{
return new Region(
- Math.Min(this.TopLeft.Row, otherRegion.TopLeft.Row),
- Math.Max(this.BottomRight.Row, otherRegion.BottomRight.Row),
- Math.Min(this.TopLeft.Col, otherRegion.TopLeft.Col),
- Math.Max(this.BottomRight.Col, otherRegion.BottomRight.Col)
+ Math.Min(this.TopLeft.row, otherRegion.TopLeft.row),
+ Math.Max(this.BottomRight.row, otherRegion.BottomRight.row),
+ Math.Min(this.TopLeft.col, otherRegion.TopLeft.col),
+ Math.Max(this.BottomRight.col, otherRegion.BottomRight.col)
);
}
public IRegion? GetIntersection(IRegion? region)
{
- var x1 = this.BottomRight.Col;
- var x2 = region.BottomRight.Col;
- var y1 = this.BottomRight.Row;
- var y2 = region.BottomRight.Row;
+ var x1 = this.BottomRight.col;
+ var x2 = region.BottomRight.col;
+ var y1 = this.BottomRight.row;
+ var y2 = region.BottomRight.row;
IRegion? intersection = null;
- var xL = Math.Max(this.TopLeft.Col, region.TopLeft.Col);
+ var xL = Math.Max(this.TopLeft.col, region.TopLeft.col);
var xR = Math.Min(x1, x2);
if (xR < xL)
intersection = null;
else
{
var yB = Math.Min(y1, y2);
- var yT = Math.Max(this.TopLeft.Row, region.TopLeft.Row);
+ var yT = Math.Max(this.TopLeft.row, region.TopLeft.row);
if (yB < yT)
intersection = null;
else
@@ -357,14 +370,20 @@ public virtual void ExtendTo(int row, int col, IRegion? regionLimit = null)
public List Break(CellPosition position)
{
- return Break(new Region(position.Row, position.Col));
+ return Break(new Region(position.row, position.col));
}
public List Break(IRegion inputRegion)
{
var region = inputRegion.GetIntersection(this);
+ // If there's no intersection then there's no break and so
+ // we return this.
if (region == null)
- return new List() { this.Copy() };
+ return new List() { this };
+ // If the region contains this then we break the whole thing and return
+ // an empty list
+ if (region.Contains(this))
+ return new List();
// The region can split into at most 4 regions
// We attempt to create all the regions and don't use any that are empty
@@ -382,45 +401,75 @@ public List Break(IRegion inputRegion)
// | \\ | \\ | 3 |
// | 4 | 4 | 4 |
- var r1IsEmpty = this.TopLeft.Row == region.TopLeft.Row;
- var r2IsEmpty = this.TopLeft.Col == region.TopLeft.Col;
- var r3IsEmpty = this.BottomRight.Col == region.BottomRight.Col;
- var r4IsEmpty = this.BottomRight.Row == region.BottomRight.Row;
+ var r1IsEmpty = this.TopLeft.row == region.TopLeft.row;
+ var r2IsEmpty = this.TopLeft.col == region.TopLeft.col;
+ var r3IsEmpty = this.BottomRight.col == region.BottomRight.col;
+ var r4IsEmpty = this.BottomRight.row == region.BottomRight.row;
var regions = new List();
if (!r1IsEmpty)
{
- var r1 = new Region(this.TopLeft.Row, region.TopLeft.Row - 1,
- this.TopLeft.Col,
- this.BottomRight.Col);
+ var r1 = new Region(this.TopLeft.row, region.TopLeft.row - 1,
+ this.TopLeft.col,
+ this.BottomRight.col);
regions.Add(r1);
}
if (!r2IsEmpty)
{
- var r2 = new Region(region.TopLeft.Row, region.BottomRight.Row, this.TopLeft.Col,
- region.TopLeft.Col - 1);
+ var r2 = new Region(region.TopLeft.row, region.BottomRight.row, this.TopLeft.col,
+ region.TopLeft.col - 1);
regions.Add(r2);
}
if (!r3IsEmpty)
{
- var r3 = new Region(region.TopLeft.Row, region.BottomRight.Row, region.BottomRight.Col + 1,
- this.BottomRight.Col);
+ var r3 = new Region(region.TopLeft.row, region.BottomRight.row, region.BottomRight.col + 1,
+ this.BottomRight.col);
regions.Add(r3);
}
if (!r4IsEmpty)
{
- var r4 = new Region(region.BottomRight.Row + 1, this.BottomRight.Row, this.TopLeft.Col,
- this.BottomRight.Col);
+ var r4 = new Region(region.BottomRight.row + 1, this.BottomRight.row, this.TopLeft.col,
+ this.BottomRight.col);
regions.Add(r4);
}
return regions;
}
+ public List Break(IEnumerable regions)
+ {
+ var allBroken = new List() { this };
+ var newBroken = new List();
+ var toRemove = new List();
+
+ foreach (var region in regions)
+ {
+ toRemove.Clear();
+ newBroken.Clear();
+
+ foreach (var broken in allBroken)
+ {
+ if (broken.GetIntersection(region) == null)
+ continue;
+ else
+ {
+ toRemove.Add(broken);
+ newBroken.AddRange(broken.Break(region));
+ }
+ }
+
+ foreach (var remove in toRemove)
+ allBroken.Remove(remove);
+ allBroken.AddRange(newBroken);
+ }
+
+ return allBroken;
+ }
+
[Obsolete]
///
/// Returns a new copy of the region with the row, col starting point
@@ -430,25 +479,25 @@ public List Break(IRegion inputRegion)
public IRegion CopyOrdered()
{
return new Region(
- Math.Min(TopLeft.Row, BottomRight.Row),
- Math.Max(TopLeft.Row, BottomRight.Row),
- Math.Min(TopLeft.Col, BottomRight.Col),
- Math.Max(TopLeft.Col, BottomRight.Col)
+ Math.Min(TopLeft.row, BottomRight.row),
+ Math.Max(TopLeft.row, BottomRight.row),
+ Math.Min(TopLeft.col, BottomRight.col),
+ Math.Max(TopLeft.col, BottomRight.col)
);
}
public IEnumerator GetEnumerator()
{
- var rowDir = BottomRight.Row >= TopLeft.Row ? 1 : -1;
- var colDir = BottomRight.Col >= TopLeft.Col ? 1 : -1;
- var row = TopLeft.Row;
- var col = TopLeft.Col;
+ var rowDir = BottomRight.row >= TopLeft.row ? 1 : -1;
+ var colDir = BottomRight.col >= TopLeft.col ? 1 : -1;
+ var row = TopLeft.row;
+ var col = TopLeft.col;
for (var i = 0; i < Height; i++)
{
// Reset column at start of each row
- col = TopLeft.Col;
+ col = TopLeft.col;
for (var j = 0; j < Width; j++)
{
@@ -462,17 +511,56 @@ public IEnumerator GetEnumerator()
public override string ToString()
{
- return $"region from (r{TopLeft.Row}, c{TopLeft.Col}) to (r{BottomRight.Row}, c{BottomRight.Col})";
+ return $"region from (r{TopLeft.row}, c{TopLeft.col}) to (r{BottomRight.row}, c{BottomRight.col})";
}
- public override bool Equals(object? obj)
+ public bool Equals(IRegion? obj)
{
if (obj is IRegion region)
- return region.TopLeft.Row == TopLeft.Row
- && region.TopLeft.Col == TopLeft.Col
- && region.BottomRight.Row == BottomRight.Row
- && region.BottomRight.Col == BottomRight.Col;
+ return region.TopLeft.row == TopLeft.row
+ && region.TopLeft.col == TopLeft.col
+ && region.BottomRight.row == BottomRight.row
+ && region.BottomRight.col == BottomRight.col;
return false;
}
+
+ ///
+ /// Returns a new region from the region string, e.g A1, A1:A4, A:A, 4:5, etc.
+ /// The string may contain $ but they are ignored.
+ ///
+ ///
+ ///
+ public static IRegion? FromString(string regionString)
+ {
+ if (string.IsNullOrEmpty(regionString))
+ return null;
+
+ // probably could be more efficient
+ var split = regionString.Split(':');
+ if (split.Length == 1 && RangeText.IsValidCellReference(split[0]))
+ return new Region(ParseCellPosition(split[0]));
+ if (split.Length == 2)
+ {
+ if (RangeText.IsValidCellReference(split[0]) &&
+ RangeText.IsValidCellReference(split[1]))
+ return new Region(ParseCellPosition(split[0]), ParseCellPosition(split[1]));
+
+ if (RangeText.IsValidColReference(split[0]) &&
+ RangeText.IsValidColReference(split[1]))
+ return new ColumnRegion(RangeText.ColStrToNumber(split[0]), RangeText.ColStrToNumber(split[1]));
+
+ if (RangeText.IsValidRowReference(split[0]) &&
+ RangeText.IsValidRowReference(split[1]))
+ return new RowRegion(RangeText.RowStrToNumber(split[0]), RangeText.RowStrToNumber(split[1]));
+ }
+
+ return null;
+ }
+
+ private static CellPosition ParseCellPosition(string cellText)
+ {
+ var result = RangeText.CellFromString(cellText)!;
+ return new CellPosition(result.row, result.col);
+ }
}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.DataStructures/Geometry/RegionCollection.cs b/src/BlazorDatasheet.DataStructures/Geometry/RegionCollection.cs
new file mode 100644
index 00000000..f4f1518d
--- /dev/null
+++ b/src/BlazorDatasheet.DataStructures/Geometry/RegionCollection.cs
@@ -0,0 +1,36 @@
+namespace BlazorDatasheet.DataStructures.Geometry;
+
+///
+/// Holds a collection of regions. The regions are stored in an RTree for efficient positional lookup.
+///
+public class RegionCollection
+{
+ ///
+ /// Adds a region to the collection.
+ ///
+ ///
+ ///
+ void Add(IRegion region)
+ {
+ throw new NotImplementedException();
+ }
+
+ ///
+ /// Cuts the region by removing parts of the region intersecting with any regions.
+ ///
+ ///
+ void Cut(IRegion region)
+ {
+ throw new NotImplementedException();
+ }
+
+ ///
+ /// Returns all regions intersecting with the region given
+ ///
+ ///
+ ///
+ IRegion[] GetIntersecting(IRegion region)
+ {
+ throw new NotImplementedException();
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet/Data/RowRegion.cs b/src/BlazorDatasheet.DataStructures/Geometry/RowRegion.cs
similarity index 69%
rename from src/BlazorDatasheet/Data/RowRegion.cs
rename to src/BlazorDatasheet.DataStructures/Geometry/RowRegion.cs
index a1781e98..5f15d8ca 100644
--- a/src/BlazorDatasheet/Data/RowRegion.cs
+++ b/src/BlazorDatasheet.DataStructures/Geometry/RowRegion.cs
@@ -1,9 +1,9 @@
-using BlazorDatasheet.Util;
+using BlazorDatasheet.DataStructures.Util;
-namespace BlazorDatasheet.Data;
+namespace BlazorDatasheet.DataStructures.Geometry;
///
-/// A column region. This region does not have an end position.
+/// A row region. This region does not have an end row
///
public class RowRegion : Region
{
@@ -17,7 +17,7 @@ public RowRegion(int row) : this(row, row)
public override IRegion Copy()
{
- return new RowRegion(TopLeft.Row, BottomRight.Row);
+ return new RowRegion(TopLeft.row, BottomRight.row);
}
public override void ExtendTo(int row, int col, IRegion? regionLimit = null)
@@ -30,7 +30,7 @@ public override void ExtendTo(int row, int col, IRegion? regionLimit = null)
}
var newRowEnd = SheetMath
- .ClampInt(regionLimit.TopLeft.Row, regionLimit.BottomRight.Row, row);
+ .ClampInt(regionLimit.TopLeft.row, regionLimit.BottomRight.row, row);
End = new CellPosition(newRowEnd, int.MaxValue);
SetOrderedBounds();
@@ -48,8 +48,8 @@ public override void Expand(Edge edges, int amount)
public override IRegion GetBoundingRegion(IRegion otherRegion)
{
- return new RowRegion(Math.Min(otherRegion.TopLeft.Row, this.TopLeft.Row),
- Math.Max(otherRegion.BottomRight.Row, this.BottomRight.Row));
+ return new RowRegion(Math.Min(otherRegion.TopLeft.row, this.TopLeft.row),
+ Math.Max(otherRegion.BottomRight.row, this.BottomRight.row));
}
public override void Shift(int dRow, int dCol)
@@ -59,6 +59,6 @@ public override void Shift(int dRow, int dCol)
public override IRegion Clone()
{
- return new RowRegion(this.Start.Row, this.End.Row);
+ return new RowRegion(this.Start.row, this.End.row);
}
}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.DataStructures/Graph/CellVertex.cs b/src/BlazorDatasheet.DataStructures/Graph/CellVertex.cs
new file mode 100644
index 00000000..f6c17726
--- /dev/null
+++ b/src/BlazorDatasheet.DataStructures/Graph/CellVertex.cs
@@ -0,0 +1,15 @@
+namespace BlazorDatasheet.DataStructures.Graph;
+
+public class CellVertex : Vertex
+{
+ public CellVertex(int row, int col)
+ {
+ Row = row;
+ Col = col;
+ Key = row + "," + col;
+ }
+
+ public int Row { get; }
+ public int Col { get; }
+ public override string Key { get; }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.DataStructures/Graph/DependencyGraph.cs b/src/BlazorDatasheet.DataStructures/Graph/DependencyGraph.cs
new file mode 100644
index 00000000..cfdae866
--- /dev/null
+++ b/src/BlazorDatasheet.DataStructures/Graph/DependencyGraph.cs
@@ -0,0 +1,203 @@
+namespace BlazorDatasheet.DataStructures.Graph;
+
+public class DependencyGraph
+{
+ ///
+ /// Adjacency list - specifies directed edges between vertices
+ /// Note this is a dictionary of a dictionary
+ ///
+ private readonly Dictionary> _adj;
+
+ ///
+ /// Precedents list - reverse of adjacency list
+ ///
+ private readonly Dictionary> _prec;
+
+ ///
+ /// Maps between vertex key and Vertex
+ ///
+ private readonly Dictionary _symbolTable;
+
+ private int _numVertices;
+ private int _numEdges;
+
+ ///
+ /// The number of vertices in the graph
+ ///
+ public int V => _numVertices;
+
+ ///
+ /// The number of edges in the graph
+ ///
+ public int E => _numEdges;
+
+ private readonly TopologicalSort _topo = new();
+
+ public DependencyGraph()
+ {
+ _adj = new();
+ _prec = new();
+ _symbolTable = new Dictionary();
+ }
+
+ ///
+ /// Adds vertex to the graph
+ ///
+ ///
+ ///
+ public void AddVertex(Vertex v)
+ {
+ if (!_symbolTable.ContainsKey(v.Key))
+ {
+ _symbolTable.Add(v.Key, v);
+ _adj.Add(v.Key, new Dictionary());
+ _prec.Add(v.Key, new Dictionary());
+ _numVertices++;
+ }
+ }
+
+ public IEnumerable GetAll() => _symbolTable.Values;
+
+ ///
+ /// Return the vertices adjacent to vertex v
+ ///
+ ///
+ ///
+ public IEnumerable Adj(Vertex v)
+ {
+ var isPresent = _symbolTable.ContainsKey(v.Key);
+ if (!isPresent)
+ return Enumerable.Empty();
+ return _adj[v.Key].Values;
+ }
+
+ ///
+ /// Return the precedent vertices to vertex v
+ ///
+ ///
+ ///
+ public IEnumerable Prec(Vertex v)
+ {
+ var isPresent = _symbolTable.ContainsKey(v.Key);
+ if (!isPresent)
+ return Enumerable.Empty();
+ return _prec[v.Key].Values;
+ }
+
+ ///
+ /// Removes the vertex v and any associated edges
+ ///
+ ///
+ ///
+ ///
+ public void RemoveVertex(Vertex v)
+ {
+ if (!_symbolTable.ContainsKey(v.Key))
+ return;
+ var adj = Adj(v);
+ var prec = Prec(v);
+ // keep a list of vertices that we removed edges to because we want to remove those if they
+ // no longer have any references
+ var toRemoveSet = new HashSet();
+
+ // Remove edges
+ foreach (var w in adj)
+ {
+ RemoveEdge(v, w);
+ }
+
+ foreach (var w in prec)
+ {
+ RemoveEdge(w, v);
+ }
+
+ _symbolTable.Remove(v.Key);
+ _adj.Remove(v.Key);
+ _prec.Remove(v.Key);
+ _numVertices--;
+ }
+
+ ///
+ /// Removes the edge that links v -> w (not this is not an associative operation)
+ /// If there is an edge between w -> v it is not removed.
+ ///
+ ///
+ ///
+ public void RemoveEdge(Vertex v, Vertex w)
+ {
+ if (_symbolTable.ContainsKey(v.Key))
+ {
+ if (_adj[v.Key].ContainsKey(w.Key))
+ {
+ _adj[v.Key].Remove(w.Key);
+ _prec[w.Key].Remove(v.Key);
+ _numEdges--;
+ }
+ }
+ }
+
+ ///
+ /// Adds an edge between the two vertices.
+ /// If the vertices are not already present, they are added
+ ///
+ ///
+ ///
+ public void AddEdge(Vertex v, Vertex w)
+ {
+ AddVertex(v);
+ AddVertex(w);
+ if (!_adj[v.Key].ContainsKey(w.Key))
+ {
+ _adj[v.Key].Add(w.Key, w);
+ _prec[w.Key].Add(v.Key, v);
+ _numEdges++;
+ }
+ }
+
+ ///
+ /// Whether a vertex is connected to any other vertices.
+ ///
+ ///
+ ///
+ public bool IsDependedOn(Vertex v)
+ {
+ return Adj(v).Any();
+ }
+
+ ///
+ /// Adds edges between the vertex v and all vertices in the array ws
+ ///
+ ///
+ ///
+ public void AddEdges(Vertex v, IEnumerable ws)
+ {
+ foreach (var w in ws)
+ AddEdge(v, w);
+ }
+
+ ///
+ /// Adds edges between the vertex v and all vertices in the array ws
+ ///
+ ///
+ ///
+ public void AddEdges(IEnumerable vs, Vertex w)
+ {
+ foreach (var v in vs)
+ AddEdge(v, w);
+ }
+
+ public IEnumerable TopologicalSort()
+ {
+ return _topo.Sort(this);
+ }
+
+ ///
+ /// Checks whether a vertex with the key given exists in the graph.
+ ///
+ ///
+ ///
+ public bool HasVertex(string key)
+ {
+ return _symbolTable.ContainsKey(key);
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.DataStructures/Graph/NamedVertex.cs b/src/BlazorDatasheet.DataStructures/Graph/NamedVertex.cs
new file mode 100644
index 00000000..1c16d105
--- /dev/null
+++ b/src/BlazorDatasheet.DataStructures/Graph/NamedVertex.cs
@@ -0,0 +1,13 @@
+namespace BlazorDatasheet.DataStructures.Graph;
+
+public class NamedVertex : Vertex
+{
+ private readonly string _name;
+
+ public NamedVertex(string name)
+ {
+ _name = name;
+ }
+
+ public override string Key => _name;
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.DataStructures/Graph/RegionVertex.cs b/src/BlazorDatasheet.DataStructures/Graph/RegionVertex.cs
new file mode 100644
index 00000000..0d4852cd
--- /dev/null
+++ b/src/BlazorDatasheet.DataStructures/Graph/RegionVertex.cs
@@ -0,0 +1,16 @@
+using BlazorDatasheet.DataStructures.Geometry;
+
+namespace BlazorDatasheet.DataStructures.Graph;
+
+public class RegionVertex : Vertex
+{
+ public RegionVertex(IRegion region, string regionName)
+ {
+ Region = region;
+ Key = regionName;
+ }
+
+ public override string Key { get; }
+
+ public IRegion Region { get; }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.DataStructures/Graph/TopologicalSort.cs b/src/BlazorDatasheet.DataStructures/Graph/TopologicalSort.cs
new file mode 100644
index 00000000..3a24a421
--- /dev/null
+++ b/src/BlazorDatasheet.DataStructures/Graph/TopologicalSort.cs
@@ -0,0 +1,38 @@
+namespace BlazorDatasheet.DataStructures.Graph;
+
+public class TopologicalSort
+{
+ private Stack _order;
+ private HashSet _marked;
+
+ public IEnumerable Sort(DependencyGraph g)
+ {
+ _order = new Stack();
+ _marked = new();
+
+ // TODO graph must be DAG so handle cycles
+
+ foreach (var v in g.GetAll())
+ if (!Marked(v))
+ dfs(g, v);
+
+ return _order;
+ }
+
+ private bool Marked(Vertex v)
+ {
+ return _marked.Contains(v.Key);
+ }
+
+ private void dfs(DependencyGraph g, Vertex v)
+ {
+ _marked.Add(v.Key);
+ foreach (var w in g.Adj(v))
+ {
+ if (!Marked(w))
+ dfs(g, w);
+ }
+
+ _order.Push(v);
+ }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.DataStructures/Graph/Vertex.cs b/src/BlazorDatasheet.DataStructures/Graph/Vertex.cs
new file mode 100644
index 00000000..f6105e58
--- /dev/null
+++ b/src/BlazorDatasheet.DataStructures/Graph/Vertex.cs
@@ -0,0 +1,6 @@
+namespace BlazorDatasheet.DataStructures.Graph;
+
+public abstract class Vertex
+{
+ public abstract string Key { get; }
+}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.DataStructures/Intervals/NonOverlappingIntervals.cs b/src/BlazorDatasheet.DataStructures/Intervals/MergeableIntervalStore.cs
similarity index 54%
rename from src/BlazorDatasheet.DataStructures/Intervals/NonOverlappingIntervals.cs
rename to src/BlazorDatasheet.DataStructures/Intervals/MergeableIntervalStore.cs
index 2116a899..254d2aeb 100644
--- a/src/BlazorDatasheet.DataStructures/Intervals/NonOverlappingIntervals.cs
+++ b/src/BlazorDatasheet.DataStructures/Intervals/MergeableIntervalStore.cs
@@ -1,4 +1,4 @@
-using BlazorDatasheet.Data;
+using System.Diagnostics;
using BlazorDatasheet.DataStructures.Search;
namespace BlazorDatasheet.DataStructures.Intervals;
@@ -8,7 +8,7 @@ namespace BlazorDatasheet.DataStructures.Intervals;
/// When a new interval is added, the data from that interval is merged into any existing.
///
///
-public class NonOverlappingIntervals where T : IMergeable
+public class MergeableIntervalStore where T : IMergeable
{
///
/// The minimum value of all ranges
@@ -27,6 +27,22 @@ public class NonOverlappingIntervals where T : IMergeable
///
private SortedList> _Intervals { get; } = new();
+ ///
+ /// The default value returned if there is no value found.
+ ///
+ public T? DefaultValue { get; }
+
+ public MergeableIntervalStore(T? defaultValue = default(T))
+ {
+ DefaultValue = defaultValue;
+ }
+
+ ///
+ /// Whether we have any intervals stored.
+ ///
+ ///
+ public bool Any() => _Intervals.Any();
+
///
/// Returns the data (if any) associated with the interval containing the position
///
@@ -35,10 +51,10 @@ public class NonOverlappingIntervals where T : IMergeable
public T? Get(int position)
{
if (!_Intervals.Any())
- return default(T);
+ return DefaultValue;
if (position < Start || position > End)
- return default(T);
+ return DefaultValue;
var i0 = _Intervals.Keys.BinarySearchIndexOf(position);
if (i0 < 0)
@@ -50,44 +66,59 @@ public class NonOverlappingIntervals where T : IMergeable
// but it can't be that interval because position < start.
// so we check the one before i0 to see if position is contained
if (i0 - 1 < 0)
- return default(T);
+ return DefaultValue;
if (_Intervals[_Intervals.Keys[i0 - 1]].Contains(position))
return _Intervals[_Intervals.Keys[i0 - 1]].Data;
- return default(T);
+ return DefaultValue;
+ }
+
+ public List> Add(int start, int end, T value)
+ {
+ return Add(new OrderedInterval(start, end, value));
}
///
/// Adds the interval and merges any overlapping data into it.
///
///
- public void Add(OrderedInterval interval)
+ /// Intervals that were either modified or removed while adding
+ public List> Add(OrderedInterval interval)
{
Start = Math.Min(interval.Start, Start);
End = Math.Max(interval.End, End);
- var overlapping = GetOverlappingIntervals(interval);
+ var overlapping = GetIntervals(interval);
if (!overlapping.Any())
{
_Intervals.Add(interval.Start, interval);
- return;
+ UpdateStartEndPositions();
+ return new List>()
+ {
+ new OrderedInterval(interval.Start, interval.End, DefaultValue)
+ };
}
// Handle when interval extends before the first overlapping interval
if (interval.Start < overlapping.First().Start)
_Intervals.Add(interval.Start,
- new OrderedInterval(interval.Start, overlapping.First().Start - 1, interval.Data));
+ new OrderedInterval(interval.Start, overlapping.First().Start - 1, interval.Data));
// Handle when interval extends after the last overlapping interval
if (interval.End > overlapping.Last().End)
_Intervals.Add(overlapping.Last().End + 1,
- new OrderedInterval(overlapping.Last().End + 1, interval.End, interval.Data));
+ new OrderedInterval(overlapping.Last().End + 1, interval.End, interval.Data));
+
+ var modified = new List>();
for (int i = 0; i < overlapping.Count; i++)
{
var oi = overlapping[i];
if (interval.Contains(oi))
{
+ // We will have modified/removed the original data, so store it so we can keep a record (for undo)
+ // in this case it is the entire interval because it was contained inside the added interval.
+ modified.Add(new OrderedInterval(oi.Start, oi.End, oi.Data.Clone()));
oi.Data = oi.Data.Clone();
oi.Data.Merge(interval.Data);
}
@@ -98,6 +129,10 @@ public void Add(OrderedInterval interval)
// and i = interval we are adding
// we remove o and add o0, and o1 so that we now have
// [o0, o0, i, i, o1, o1]
+
+ // first store the (removed) original data that was in o.
+ modified.Add(new OrderedInterval(interval.Start, interval.End, oi.Data.Clone()));
+
_Intervals.Remove(oi.Start);
if (oi.Start != interval.Start)
_Intervals.Add(oi.Start, new OrderedInterval(oi.Start, interval.Start - 1, oi.Data));
@@ -110,6 +145,10 @@ public void Add(OrderedInterval interval)
else if (interval.Start > oi.Start)
{
+ // [o, o, i, i] i, i
+ // first store the (removed) original data from o
+ modified.Add(new OrderedInterval(interval.Start, oi.End, oi.Data.Clone()));
+
_Intervals.Remove(oi.Start);
var old = new OrderedInterval(oi.Start, interval.Start - 1, oi.Data);
var merged = new OrderedInterval(interval.Start, oi.End, oi.Data.Clone());
@@ -119,10 +158,14 @@ public void Add(OrderedInterval interval)
}
else if (interval.End < oi.End)
{
+ // i, i [i, i, o, o]
+ // first store the (removed) original data from o
+ modified.Add(new OrderedInterval(oi.Start, interval.End, oi.Data.Clone()));
+
_Intervals.Remove(oi.Start);
var old = new OrderedInterval(interval.End + 1, oi.End, oi.Data);
- var merged = new OrderedInterval(oi.Start, interval.Start - 1, oi.Data.Clone());
- old.Data.Merge(interval.Data);
+ var merged = new OrderedInterval(oi.Start, interval.End, oi.Data.Clone());
+ merged.Data.Merge(interval.Data);
_Intervals.Add(old.Start, old);
_Intervals.Add(merged.Start, merged);
}
@@ -131,14 +174,31 @@ public void Add(OrderedInterval interval)
if (i >= overlapping.Count - 1)
continue;
+ // we know the next one is overlapping too,
+ // but there's a hole that won't be plugged unless we do it now
+ // [oi, oi, oi], i, i, i, [oi+1, oi+1, o1+1]
var gap = overlapping[i + 1].Start - oi.End;
if (gap > 1)
_Intervals.Add(
oi.End + 1, new OrderedInterval(oi.End + 1, overlapping[i + 1].Start - 1, interval.Data));
}
+
+ UpdateStartEndPositions();
+ return modified;
}
- public List> GetOverlappingIntervals(OrderedInterval interval)
+ ///
+ /// Returns all overlapping intervals between the start and end position.
+ ///
+ ///
+ ///
+ ///
+ public List> GetIntervals(int start, int end)
+ {
+ return GetIntervals(new OrderedInterval(start, end));
+ }
+
+ public List> GetIntervals(OrderedInterval interval)
{
var overlapping = new List>();
@@ -163,22 +223,33 @@ public List> GetOverlappingIntervals(OrderedInterval interval
public IList> GetAllIntervals() => _Intervals.Values.ToList();
///
- /// Deletes the interval from storage
+ /// Remove the interval from storage
+ ///
+ ///
+ /// The ordered intervals that were removed during the process.
+ public List> Clear(int start, int end)
+ {
+ return Clear(new OrderedInterval(start, end));
+ }
+
+ ///
+ /// Remove the interval from storage
///
///
- public void Delete(OrderedInterval interval)
+ /// The ordered intervals that were removed during the process.
+ public List> Clear(OrderedInterval interval)
{
if (!_Intervals.Any())
- return;
+ return new List>();
if (interval.End < Start || interval.Start > End)
- return;
+ return new List>();
var i0 = _Intervals.Keys.BinarySearchIndexOf(interval.Start);
if (i0 < 0)
i0 = ~i0;
- // We now have either the
+ // We now have either the interval or the one to the right of it
OrderedInterval currentInterval;
// Start with a good guess of where the interval starts which is to the left
@@ -196,11 +267,12 @@ public void Delete(OrderedInterval interval)
// In case 1 & 2 we shorten the other intervals by the overlapping amount. 1 = splitRight, 2 = splitLeft.
// intervals to remove
- List> toRemove = new();
+ List> removed = new();
// The interval to split left (if any)
OrderedInterval? splitLeft = null;
// The interval to split right (if any). Note splitLeft may be equal to split right.
OrderedInterval? splitRight = null;
+
for (int i = i0; i < _Intervals.Count; i++)
{
var existingInterval = _Intervals[_Intervals.Keys[i]];
@@ -209,7 +281,7 @@ public void Delete(OrderedInterval interval)
if (interval.Contains(existingInterval))
{
- toRemove.Add(existingInterval);
+ removed.Add(existingInterval);
continue;
}
@@ -220,43 +292,109 @@ public void Delete(OrderedInterval interval)
splitLeft = existingInterval;
}
- foreach (var intervalToRemove in toRemove)
+ foreach (var intervalToRemove in removed)
_Intervals.Remove(intervalToRemove.Start);
// we need to work with split right first because split left may depend on it
if (splitRight != null)
{
+ removed.Add(new OrderedInterval(interval.Start, Math.Min(interval.End, splitRight.End),
+ splitRight.Data.Clone()));
_Intervals.Remove(splitRight.Start);
_Intervals.Add(splitRight.Start,
- new OrderedInterval(splitRight.Start, interval.Start - 1, splitRight.Data));
+ new OrderedInterval(splitRight.Start, interval.Start - 1, splitRight.Data));
}
if (splitLeft != null)
{
- if (splitLeft != splitRight)
+ if (splitLeft != splitRight) // we may have already removed split Right, so don't remove it twice
+ {
_Intervals.Remove(splitLeft.Start);
+ removed.Add(new OrderedInterval(Math.Max(splitLeft.Start, interval.Start), interval.End,
+ splitLeft.Data.Clone()));
+ }
+
_Intervals.Add(interval.End + 1, new OrderedInterval(interval.End + 1, splitLeft.End, splitLeft.Data));
}
- // Update start and end positions of store
- if (_Intervals.Any())
+ UpdateStartEndPositions();
+ return removed;
+ }
+
+ ///
+ /// Shifts all intervals to the right of , to the right by
+ /// If from is inside an overlapping interval, the end gets extended
+ /// If from is at the start of an overlapping interval, the interval is shifted right
+ ///
+ /// The position where everything to the right gets shifted right.
+ ///
+ public void ShiftRight(int from, int n)
+ {
+ var overlapping = this.GetIntervals(from, Math.Max(this.End, from));
+ // need to work backwards so we don't end up with adding keys
+ // that already exist
+ for (int i = overlapping.Count - 1; i >= 0; i--)
{
- Start = _Intervals.First().Value.Start;
- End = _Intervals.Last().Value.End;
+ var oi = overlapping[i];
+ if (oi.Start < from)
+ oi.End += n;
+ else
+ {
+ _Intervals.Remove(oi.Start);
+ _Intervals.Add(oi.Start + n, new OrderedInterval(oi.Start + n, oi.End + n, oi.Data));
+ }
}
+
+ UpdateStartEndPositions();
}
///
- /// Clones all intervals (including data) and returns the list of cloned intervals
+ /// Shifts all intervals to the right of , to the left by
+ /// If from is inside an overlapping interval, the end gets contracted
///
- ///
- public IEnumerable> CloneAllIntervals()
+ /// The position where everything to the right gets shifted left.
+ ///
+ public void ShiftLeft(int from, int n)
+ {
+ var removed = new List>();
+
+ var overlapping = this.GetIntervals(from, Math.Max(from, this.End));
+
+ for (int i = 0; i < overlapping.Count; i++)
+ {
+ var oi = overlapping[i];
+ if (oi.Start <= from)
+ {
+ if (oi.End - n >= oi.Start) // we end up with an interval of length 1 or greater
+ oi.End -= n;
+ // Anything that is shifted to the left of from gets removed. This shouldn't
+ // really happen in reality because when we are using it, it will be with a cut also
+ else
+ _Intervals.Remove(oi.Start);
+ }
+ else
+ {
+ _Intervals.Remove(oi.Start);
+ // if it doesn't move partially past from, we can just shift the whole thing.
+ if (oi.Start - n >= from)
+ _Intervals.Add(oi.Start - n, new OrderedInterval(oi.Start - n, oi.End - n, oi.Data));
+ else
+ {
+ _Intervals.Add(from, new OrderedInterval(from, oi.End - n, oi.Data));
+ }
+ }
+ }
+
+ UpdateStartEndPositions();
+ }
+
+ private void UpdateStartEndPositions()
{
- var clones =
- _Intervals
- .Values
- .Select(x => new OrderedInterval(x.Start, x.End, x.Data.Clone()));
- return clones.ToList();
+ if (_Intervals.Any())
+ {
+ Start = _Intervals.First().Value.Start;
+ End = _Intervals.Last().Value.End;
+ }
}
public void AddRange(IEnumerable> intervals)
diff --git a/src/BlazorDatasheet.DataStructures/Intervals/OrderedInterval.cs b/src/BlazorDatasheet.DataStructures/Intervals/OrderedInterval.cs
index b275df21..bb320675 100644
--- a/src/BlazorDatasheet.DataStructures/Intervals/OrderedInterval.cs
+++ b/src/BlazorDatasheet.DataStructures/Intervals/OrderedInterval.cs
@@ -1,4 +1,4 @@
-namespace BlazorDatasheet.Data;
+namespace BlazorDatasheet.DataStructures.Intervals;
///
/// An ordered interval between its start and end position (inclusive)
@@ -112,6 +112,11 @@ public static List Merge(params OrderedInterval[] intervals)
{
return Merge(intervals.AsEnumerable());
}
+
+ public override string ToString()
+ {
+ return $"[{Start},{End}]";
+ }
}
public class OrderedInterval : OrderedInterval
@@ -127,4 +132,9 @@ public OrderedInterval(int start, int end, T data) : base(start, end)
{
return new OrderedInterval(Start, End, Data);
}
+
+ public override string ToString()
+ {
+ return $"[{Start},{End}]:{Data.ToString()}";
+ }
}
\ No newline at end of file
diff --git a/src/BlazorDatasheet.DataStructures/RTree/Envelope.cs b/src/BlazorDatasheet.DataStructures/RTree/Envelope.cs
index 80d1592b..6eae1c4a 100644
--- a/src/BlazorDatasheet.DataStructures/RTree/Envelope.cs
+++ b/src/BlazorDatasheet.DataStructures/RTree/Envelope.cs
@@ -107,10 +107,10 @@ public bool Contains(in Envelope other) =>
/// otherwise.
///
public bool Intersects(in Envelope other) =>
- this.MinX <= other.MaxX &&
- this.MinY <= other.MaxY &&
- this.MaxX >= other.MinX &&
- this.MaxY >= other.MinY;
+ this.MinX < other.MaxX &&
+ this.MinY < other.MaxY &&
+ this.MaxX > other.MinX &&
+ this.MaxY > other.MinY;
///
/// A bounding box that contains the entire 2-d plane.
diff --git a/src/BlazorDatasheet.DataStructures/RTree/RTree.cs b/src/BlazorDatasheet.DataStructures/RTree/RTree.cs
index 8d850f88..676a707f 100644
--- a/src/BlazorDatasheet.DataStructures/RTree/RTree.cs
+++ b/src/BlazorDatasheet.DataStructures/RTree/RTree.cs
@@ -24,6 +24,8 @@
// modified to suit the blazor datasheet project.
using System.Diagnostics.CodeAnalysis;
+using BlazorDatasheet.DataStructures.Geometry;
+using BlazorDatasheet.DataStructures.Util;
namespace BlazorDatasheet.DataStructures.RTree;
diff --git a/src/BlazorDatasheet.DataStructures/Search/SearchExtensions.cs b/src/BlazorDatasheet.DataStructures/Search/SearchExtensions.cs
index 5e70e2d0..7fc1ecde 100644
--- a/src/BlazorDatasheet.DataStructures/Search/SearchExtensions.cs
+++ b/src/BlazorDatasheet.DataStructures/Search/SearchExtensions.cs
@@ -6,8 +6,8 @@ public static class SearchExtensions
/// Binary search for the index of a value. If the value is in the array, the index is returned,
/// otherwise the returned index is the index of the next highest value.
///
+ /// The array to search in
/// The value to search for
- /// The array to search in
///
public static int BinarySearchClosest(this IList list, T value) where T : IComparable
{
diff --git a/src/BlazorDatasheet.DataStructures/Store/ConsolidatedDataStore.cs b/src/BlazorDatasheet.DataStructures/Store/ConsolidatedDataStore.cs
new file mode 100644
index 00000000..5539665d
--- /dev/null
+++ b/src/BlazorDatasheet.DataStructures/Store/ConsolidatedDataStore.cs
@@ -0,0 +1,128 @@
+using BlazorDatasheet.DataStructures.Geometry;
+
+namespace BlazorDatasheet.DataStructures.Store;
+
+///
+/// A region store where regions will not overlap if added regions contain the same data.
+/// If a newly added region overlaps with any regions containing the same data, regions will be added/removed
+/// to consolidate these regions into a smaller number of non-overlapping regions.
+///
+///
+public class ConsolidatedDataStore : RegionDataStore where T : IEquatable
+{
+ ///
+ /// Keeps track of the regions that each data apply to.
+ ///
+ private Dictionary> _dataMaps { get; }
+
+ public ConsolidatedDataStore() : base()
+ {
+ _dataMaps = new Dictionary>();
+ }
+
+ internal override RegionRestoreData Add(DataRegion dataRegion)
+ {
+ var (regionsToRemove, regionsToAdd) = Consolidate(dataRegion);
+ foreach (var removal in regionsToRemove)
+ _tree.Delete(removal);
+ _tree.BulkLoad(regionsToAdd);
+
+ _dataMaps.TryAdd(dataRegion.Data, regionsToAdd.Select(x => x.Region).ToList());
+
+ foreach (var removal in regionsToRemove)
+ {
+ // since we are grabbing the regions from the tree,
+ // the region should refer to the same object as the data map stores.
+ _dataMaps[dataRegion.Data].Remove(removal.Region);
+ }
+
+ return new RegionRestoreData()
+ {
+ RegionsAdded = regionsToAdd.ToList(),
+ RegionsRemoved = regionsToRemove.ToList()
+ };
+ }
+
+ public override (List regionsRemoved, List regionsAdded) Clear(IRegion region, T data)
+ {
+ if (!_dataMaps.ContainsKey(data))
+ return (new List(), new List());
+
+ var regionsRemoved = base.Clear(region, data);
+ foreach (var removed in regionsRemoved.regionsRemoved)
+ _dataMaps[data].Remove(removed);
+ foreach (var added in regionsRemoved.regionsAdded)
+ _dataMaps[data].Add(added);
+
+ return regionsRemoved;
+ }
+
+ ///
+ /// Returns the regions associated with the given data.
+ ///
+ ///
+ ///
+ public IEnumerable GetRegions(T data)
+ {
+ //TODO use data maps... or delete them
+ // since we won't be calling this very often it doesn't have to be efficient?
+ return _tree.Search().Where(x => x.Data.Equals(data)).Select(x => x.Region);
+ }
+
+ ///
+ /// Returns the list of regions that should be removed/added when so that an added data region
+ /// results in non-overlapping regions.
+ ///
+ ///
+ ///
+ private (List> regionsToRemove, List> regionsToAdd) Consolidate(
+ DataRegion dataRegion)
+ {
+ // the assumption (which is true for this class) is that regions are always consolidated
+ // when new ones are added, so we assume that all existing regions are non-overlapping.
+ // There is most definitely a more efficient way of doing this, because we will end up with more regions
+ // than we need to.
+ var overlappingData = GetDataRegions(dataRegion.Region)
+ .Where(x => x.Data.Equals(dataRegion.Data))
+ .ToList();
+
+ var regionsToRemove = new List>();
+ var regionsToAdd = new List