From 574a39d404d33d640b21fae916737b58766da53e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ossian=20Edstr=C3=B6m?= Date: Mon, 19 Oct 2026 09:41:46 +0200 Subject: [PATCH 1/7] fix for #2596 --- .../Worksheet/WorksheetRangeInsertHelper.cs | 2 +- src/EPPlus/ExcelAddressBase.cs | 1 + .../Core/Range/Insert/RangeInsertTests.cs | 59 +++++++++++++++++++ .../Functions/RefAndLookup/ToRowTests.cs | 2 + 4 files changed, 63 insertions(+), 1 deletion(-) diff --git a/src/EPPlus/Core/Worksheet/WorksheetRangeInsertHelper.cs b/src/EPPlus/Core/Worksheet/WorksheetRangeInsertHelper.cs index ae542a4753..1432746e3a 100644 --- a/src/EPPlus/Core/Worksheet/WorksheetRangeInsertHelper.cs +++ b/src/EPPlus/Core/Worksheet/WorksheetRangeInsertHelper.cs @@ -62,7 +62,7 @@ internal static void InsertRow(ExcelWorksheet ws, int rowFrom, int rows, int cop InsertFilterAddress(range, affectedAddress, eShiftTypeInsert.Down); InsertSparkLinesAddress(range, eShiftTypeInsert.Down, affectedAddress); InsertChartSerieAddresses(range, affectedAddress, eShiftTypeInsert.Down); - InsertDataValidation(range, eShiftTypeInsert.Down, affectedAddress, ws, false); + InsertDataValidation(range, eShiftTypeInsert.Down, affectedAddress, ws, true); InsertConditionalFormatting(range, eShiftTypeInsert.Down, affectedAddress, ws, true); WorksheetRangeCommonHelper.AdjustDvAndCfFormulasRow(ws, rowFrom, rows); diff --git a/src/EPPlus/ExcelAddressBase.cs b/src/EPPlus/ExcelAddressBase.cs index 38e1d8dd1a..9c22ba933e 100644 --- a/src/EPPlus/ExcelAddressBase.cs +++ b/src/EPPlus/ExcelAddressBase.cs @@ -1168,6 +1168,7 @@ internal ExcelAddressBase AddRowFirstAddress(int row, int rows, bool setFixed = { var fromRow = setFixed && _fromRowFixed ? _fromRow : _fromRow + rows; if (fromRow > ExcelPackage.MaxRows) return null; + //CHECK THIS ON MONDAY!!! return new ExcelAddressBase(GetRow(fromRow, setRefOnMinMax), _fromCol, GetRow(toRow, setRefOnMinMax), _toCol, _fromRowFixed, _fromColFixed, _toRowFixed, _toColFixed, WorkSheetName, _address); } else diff --git a/src/EPPlusTest/Core/Range/Insert/RangeInsertTests.cs b/src/EPPlusTest/Core/Range/Insert/RangeInsertTests.cs index 4001d0dcdf..4a9c76ae3f 100644 --- a/src/EPPlusTest/Core/Range/Insert/RangeInsertTests.cs +++ b/src/EPPlusTest/Core/Range/Insert/RangeInsertTests.cs @@ -1676,5 +1676,64 @@ public void InsertColRangeMaxAbsoluteMultipleLines() } } #endregion + + // THIS FAILS: + [TestMethod] + public void InsertRow_AtFirstTableDataRow_ExtendDataValidation() + { + using (var pck = new ExcelPackage()) + { + // GIVEN a table with a header row and one data row, where the first column of the data row has a list data validation + var wks = pck.Workbook.Worksheets.Add("Sheet1"); + wks.Cells["A1"].Value = "Col1"; + wks.Cells["B1"].Value = "Col2"; + wks.Tables.Add(wks.Cells["A1:B2"], "Table1"); + + var dv = wks.DataValidations.AddListValidation("A2"); + dv.Formula.Values.Add("Yes"); + dv.Formula.Values.Add("No"); + + //wks.Cells["A2"].Insert(eShiftTypeInsert.EntireRow) + //dv.Address. + + //for (int i = 0; i < 3; i++) + //{ + // wks.Cells["A2"].Insert(eShiftTypeInsert.EntireRow); + // //wks.Cells[2, 1, 2, 1].EntireRow.Range.Insert(eShiftTypeInsert.Down); + // //wks.Cells["A2"].EntireRow.Range.Insert(eShiftTypeInsert.EntireRow); + //} + // WHEN we insert 3 rows at the first data row, so the original data row becomes the last row of the table + wks.InsertRow(3, 3, 2); + + // THEN there is still a single data validation, and it covers every data row in the table + Assert.AreEqual(1, wks.DataValidations.Count); + Assert.AreEqual("A2:A5", wks.DataValidations[0].Address.Address); + } + } + + // THIS PASSES: + [TestMethod] + public void InsertRow_BetweenTableDataRows_ExtendDataValidation() + { + using (var pck = new ExcelPackage()) + { + // GIVEN a table with a header row and two data rows, where the first column of both data rows has a list data validation + var wks = pck.Workbook.Worksheets.Add("Sheet1"); + wks.Cells["A1"].Value = "Col1"; + wks.Cells["B1"].Value = "Col2"; + wks.Tables.Add(wks.Cells["A1:B3"], "Table1"); + + var dv = wks.DataValidations.AddListValidation("A2:A3"); + dv.Formula.Values.Add("Yes"); + dv.Formula.Values.Add("No"); + + // WHEN we insert 3 rows at the second data row, so the new rows are between the two original data rows + wks.InsertRow(3, 3); + + // THEN there is still a single data validation, and it has been extended to cover every data row in the table + Assert.AreEqual(1, wks.DataValidations.Count); + Assert.AreEqual("A2:A6", wks.DataValidations[0].Address.Address); + } + } } } \ No newline at end of file diff --git a/src/EPPlusTest/FormulaParsing/Excel/Functions/RefAndLookup/ToRowTests.cs b/src/EPPlusTest/FormulaParsing/Excel/Functions/RefAndLookup/ToRowTests.cs index 81f9040de6..809c07fb51 100644 --- a/src/EPPlusTest/FormulaParsing/Excel/Functions/RefAndLookup/ToRowTests.cs +++ b/src/EPPlusTest/FormulaParsing/Excel/Functions/RefAndLookup/ToRowTests.cs @@ -136,5 +136,7 @@ public void ShouldReturnCorrectResultWithScanByColumnFalse() Assert.AreEqual(6, _sheet.Cells["E10"].Value); Assert.AreEqual(10, _sheet.Cells["F10"].Value); } + + } } From 604e403ddfeade1ab5c00a1bac4e8ce8e58cd83e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ossian=20Edstr=C3=B6m?= Date: Mon, 19 Oct 2026 09:50:05 +0200 Subject: [PATCH 2/7] Cleaned up tests --- .../Core/Range/Insert/RangeInsertTests.cs | 37 +++++++++++++------ 1 file changed, 26 insertions(+), 11 deletions(-) diff --git a/src/EPPlusTest/Core/Range/Insert/RangeInsertTests.cs b/src/EPPlusTest/Core/Range/Insert/RangeInsertTests.cs index 4a9c76ae3f..f4b19834b8 100644 --- a/src/EPPlusTest/Core/Range/Insert/RangeInsertTests.cs +++ b/src/EPPlusTest/Core/Range/Insert/RangeInsertTests.cs @@ -1677,7 +1677,7 @@ public void InsertColRangeMaxAbsoluteMultipleLines() } #endregion - // THIS FAILS: + #region i2585-related tests [TestMethod] public void InsertRow_AtFirstTableDataRow_ExtendDataValidation() { @@ -1693,16 +1693,31 @@ public void InsertRow_AtFirstTableDataRow_ExtendDataValidation() dv.Formula.Values.Add("Yes"); dv.Formula.Values.Add("No"); - //wks.Cells["A2"].Insert(eShiftTypeInsert.EntireRow) - //dv.Address. - - //for (int i = 0; i < 3; i++) - //{ - // wks.Cells["A2"].Insert(eShiftTypeInsert.EntireRow); - // //wks.Cells[2, 1, 2, 1].EntireRow.Range.Insert(eShiftTypeInsert.Down); - // //wks.Cells["A2"].EntireRow.Range.Insert(eShiftTypeInsert.EntireRow); - //} // WHEN we insert 3 rows at the first data row, so the original data row becomes the last row of the table + wks.InsertRow(2, 3); + + // THEN there is still a single data validation, and it ends up at the bottom + // Ensure we do not copy the data validation upwards by default as Excel does not. + Assert.AreEqual(1, wks.DataValidations.Count); + Assert.AreEqual("A5", wks.DataValidations[0].Address.Address); + } + } + + //Edited test for bug i2586 + [TestMethod] + public void InsertRow_UnderLastTableDataRow_ExtendDataValidation() + { + using (var pck = new ExcelPackage()) + { + // GIVEN a table with a header row and one data row, where the first column of the data row has a list data validation + var wks = pck.Workbook.Worksheets.Add("Sheet1"); + wks.Cells["A1"].Value = "Col1"; + wks.Cells["B1"].Value = "Col2"; + wks.Tables.Add(wks.Cells["A1:B2"], "Table1"); + + var dv = wks.DataValidations.AddListValidation("A2"); + dv.Formula.Values.Add("Yes"); + dv.Formula.Values.Add("No"); wks.InsertRow(3, 3, 2); // THEN there is still a single data validation, and it covers every data row in the table @@ -1711,7 +1726,6 @@ public void InsertRow_AtFirstTableDataRow_ExtendDataValidation() } } - // THIS PASSES: [TestMethod] public void InsertRow_BetweenTableDataRows_ExtendDataValidation() { @@ -1735,5 +1749,6 @@ public void InsertRow_BetweenTableDataRows_ExtendDataValidation() Assert.AreEqual("A2:A6", wks.DataValidations[0].Address.Address); } } + #endregion } } \ No newline at end of file From 6b0071005ba3e1fc3832621520c4b44cb151aeea Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ossian=20Edstr=C3=B6m?= Date: Mon, 19 Oct 2026 09:52:07 +0200 Subject: [PATCH 3/7] Added a little more credit to reporter --- src/EPPlusTest/Core/Range/Insert/RangeInsertTests.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/EPPlusTest/Core/Range/Insert/RangeInsertTests.cs b/src/EPPlusTest/Core/Range/Insert/RangeInsertTests.cs index f4b19834b8..dcb3606faf 100644 --- a/src/EPPlusTest/Core/Range/Insert/RangeInsertTests.cs +++ b/src/EPPlusTest/Core/Range/Insert/RangeInsertTests.cs @@ -1703,7 +1703,7 @@ public void InsertRow_AtFirstTableDataRow_ExtendDataValidation() } } - //Edited test for bug i2586 + //Edited tests for issue #2585. Tests originally written by issue-reporter [TestMethod] public void InsertRow_UnderLastTableDataRow_ExtendDataValidation() { From b080d8dacf5fefcb8819bddcf4fa1a7a269d8300 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ossian=20Edstr=C3=B6m?= Date: Mon, 19 Oct 2026 14:26:02 +0200 Subject: [PATCH 4/7] Added fixes for quadtree and copying --- src/EPPlus/Core/RangeCopyHelper.cs | 14 ++++-- .../Worksheet/WorksheetRangeInsertHelper.cs | 1 + src/EPPlus/ExcelAddressBase.cs | 43 ++++++++++++++++++- src/EPPlus/ExcelRangeBase.cs | 2 +- .../Core/Range/Insert/RangeInsertTests.cs | 39 ++++++++++++++++- 5 files changed, 93 insertions(+), 6 deletions(-) diff --git a/src/EPPlus/Core/RangeCopyHelper.cs b/src/EPPlus/Core/RangeCopyHelper.cs index da70afee85..78e84dbc99 100644 --- a/src/EPPlus/Core/RangeCopyHelper.cs +++ b/src/EPPlus/Core/RangeCopyHelper.cs @@ -316,7 +316,15 @@ private void CopyDataValidations() { if (_sourceRange._worksheet == _destinationRange._worksheet) { - dv.SetAddress(dv.Address + "," + newAddress); + var unifiedAddress = dv.Address.UnifyAddressesIfPossible(dv.Address, new ExcelAddressBase(newAddress)); + if (unifiedAddress != null) + { + dv.SetAddress(unifiedAddress.Address); + } + else + { + dv.SetAddress(dv.Address + "," + newAddress); + } dv._ws.DataValidations.UpdateRangeDictionary(dv); } else @@ -404,8 +412,8 @@ private string HandleAddress(ExcelAddressBase inAddress) var colOffset = address._fromCol - _sourceRange._fromCol; var fr = Math.Min(Math.Max(_destinationRange._fromRow + rowOffset, 1), ExcelPackage.MaxRows); var fc = Math.Min(Math.Max(_destinationRange._fromCol + colOffset, 1), ExcelPackage.MaxColumns); - address = EnumUtil.HasFlag(_copyOptions, ExcelRangeCopyOptionFlags.Transpose) ? new ExcelAddressBase(fc, fr, Math.Min(fc + address.Columns - 1, ExcelPackage.MaxColumns), Math.Min(fr + address.Rows - 1, ExcelPackage.MaxRows)) : - new ExcelAddressBase(fr, fc, Math.Min(fr + address.Rows-1, ExcelPackage.MaxRows), Math.Min(fc + address.Columns-1, ExcelPackage.MaxColumns)); + address = EnumUtil.HasFlag(_copyOptions, ExcelRangeCopyOptionFlags.Transpose) ? new ExcelAddressBase(fc, fr, Math.Min(fc + _destinationRange.Columns - 1, ExcelPackage.MaxColumns), Math.Min(fr + _destinationRange.Rows - 1, ExcelPackage.MaxRows)) : + new ExcelAddressBase(fr, fc, Math.Min(fr + _destinationRange.Rows-1, ExcelPackage.MaxRows), Math.Min(fc + _destinationRange.Columns-1, ExcelPackage.MaxColumns)); return address.Address; } return ""; diff --git a/src/EPPlus/Core/Worksheet/WorksheetRangeInsertHelper.cs b/src/EPPlus/Core/Worksheet/WorksheetRangeInsertHelper.cs index 1432746e3a..a3978c73d6 100644 --- a/src/EPPlus/Core/Worksheet/WorksheetRangeInsertHelper.cs +++ b/src/EPPlus/Core/Worksheet/WorksheetRangeInsertHelper.cs @@ -319,6 +319,7 @@ private static void InsertDataValidation(ExcelRangeBase range, eShiftTypeInsert { if (dv.Address.Address != newAddress.Address) { + ws.DataValidations.dvQuadTree.UpdateAddress(dv.Address, newAddress, dv); dv.SetAddress(newAddress.Address); } } diff --git a/src/EPPlus/ExcelAddressBase.cs b/src/EPPlus/ExcelAddressBase.cs index 9c22ba933e..edc04b4d8e 100644 --- a/src/EPPlus/ExcelAddressBase.cs +++ b/src/EPPlus/ExcelAddressBase.cs @@ -1168,7 +1168,6 @@ internal ExcelAddressBase AddRowFirstAddress(int row, int rows, bool setFixed = { var fromRow = setFixed && _fromRowFixed ? _fromRow : _fromRow + rows; if (fromRow > ExcelPackage.MaxRows) return null; - //CHECK THIS ON MONDAY!!! return new ExcelAddressBase(GetRow(fromRow, setRefOnMinMax), _fromCol, GetRow(toRow, setRefOnMinMax), _toCol, _fromRowFixed, _fromColFixed, _toRowFixed, _toColFixed, WorkSheetName, _address); } else @@ -2190,5 +2189,47 @@ internal ExcelAddressBase CloneWithOffset(int row, int col) } return ret; } + + //Merge/Unify two addresses + //e.g. if an address is 'A2:A4, A5' it could also be written as one unified range 'A2:A5' instead of comma separated + //NOTE: Has NOTHING to do with MergedCells or the like. + //This is purely if the addresses are continous and could be described as a singular range. + internal ExcelAddressBase UnifyAddressesIfPossible(ExcelAddressBase address1, ExcelAddressBase address2) + { + //For this to be possible without including cells that are not part of the original expression + //At least one of either row or col range must be identical + bool colRangeIsIdentical = address1.Columns == address2.Columns && address1._fromCol == address2._fromCol; + bool rowRangeIsIdentical = address1.Rows == address2.Rows && address1._fromRow == address2._fromRow; + + if (colRangeIsIdentical) + { + if(address2._toRow + 1 == address1._fromRow) + { + //Address2 above addres1 + return new ExcelAddressBase(address2._fromRow, address2._fromCol, address1._toRow, address2._toCol); + } + else if(address1._toRow + 1 == address2._fromRow) + { + //Address1 is above address2 + return new ExcelAddressBase(address1._fromRow, address1._fromCol, address2._toRow, address1._toCol); + } + } + + if (rowRangeIsIdentical) + { + if (address2._toCol + 1 == address1._fromCol) + { + //Address2 left of Address1 + return new ExcelAddressBase(address2._fromRow, address2._fromCol, address2._toRow, address1._toCol); + } + else if (address1._toCol + 1 == address2._fromCol) + { + //Address1 is left of address2 + return new ExcelAddressBase(address1._fromRow, address1._fromCol, address2._toRow, address2._toCol); + } + } + + return null; + } } } diff --git a/src/EPPlus/ExcelRangeBase.cs b/src/EPPlus/ExcelRangeBase.cs index 0f5b44f007..bdfd27065d 100644 --- a/src/EPPlus/ExcelRangeBase.cs +++ b/src/EPPlus/ExcelRangeBase.cs @@ -2105,7 +2105,7 @@ private void CopyBase(ExcelRangeBase Destination, ExcelRangeCopyOptionFlags exce var allDestinations = Destination.GetAllAddresses(); foreach (var currDest in allDestinations) { - //Arguably this is unnecessary as it should not be possible. + //Arguably it is unnecessary to place this inside an if as adddresses must be null to get here. if (currDest.Addresses == null) { var helper = new RangeCopyHelper(this, new ExcelRangeBase(Destination.Worksheet, currDest.Address), excelRangeCopyOptionFlags); diff --git a/src/EPPlusTest/Core/Range/Insert/RangeInsertTests.cs b/src/EPPlusTest/Core/Range/Insert/RangeInsertTests.cs index dcb3606faf..36c87f6161 100644 --- a/src/EPPlusTest/Core/Range/Insert/RangeInsertTests.cs +++ b/src/EPPlusTest/Core/Range/Insert/RangeInsertTests.cs @@ -1677,6 +1677,8 @@ public void InsertColRangeMaxAbsoluteMultipleLines() } #endregion + + //Edited tests for issue #2585. Tests originally written by issue-reporter #region i2585-related tests [TestMethod] public void InsertRow_AtFirstTableDataRow_ExtendDataValidation() @@ -1703,7 +1705,6 @@ public void InsertRow_AtFirstTableDataRow_ExtendDataValidation() } } - //Edited tests for issue #2585. Tests originally written by issue-reporter [TestMethod] public void InsertRow_UnderLastTableDataRow_ExtendDataValidation() { @@ -1726,6 +1727,42 @@ public void InsertRow_UnderLastTableDataRow_ExtendDataValidation() } } + [TestMethod] + public void InsertRow_UnderLastTableDataRow_VerifyQuadRangeUpdates() + { + using (var pck = new ExcelPackage()) + { + // GIVEN a table with a header row and one data row, where the first column of the data row has a list data validation + var wks = pck.Workbook.Worksheets.Add("Sheet1"); + wks.Cells["A1"].Value = "Col1"; + wks.Cells["B1"].Value = "Col2"; + wks.Tables.Add(wks.Cells["A1:B2"], "Table1"); + + var dv = wks.DataValidations.AddListValidation("A2"); + dv.Formula.Values.Add("Yes"); + dv.Formula.Values.Add("No"); + wks.InsertRow(2, 3, 2); + + var validationsAtOldAddress = wks.Cells["A2"].DataValidation.GetDataValidations(); + + //Verify data validation does not remain at old address + Assert.AreEqual(0, validationsAtOldAddress.Count); + + var validationsAtNewAddress = wks.Cells["A5"].DataValidation.GetDataValidations(); + + //Verify data validation does exist at new address + Assert.AreEqual(1, validationsAtNewAddress.Count); + + //Copy the moved validation and apply it to the new rows + wks.Cells["A5"].Copy(wks.Cells["A2:A4"], ExcelRangeCopyOnly.Validations); + + // THEN there is still a single data validation, and it covers every data row in the table + Assert.AreEqual(1, wks.DataValidations.Count); + //Verify copying Also unified the addresses instead of comma separating if possible + Assert.AreEqual("A2:A5", wks.DataValidations[0].Address.Address); + } + } + [TestMethod] public void InsertRow_BetweenTableDataRows_ExtendDataValidation() { From d39139e0b951716f239e6b5ffd3e065e8df82fa5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ossian=20Edstr=C3=B6m?= Date: Tue, 20 Oct 2026 09:37:51 +0200 Subject: [PATCH 5/7] Reverted faulty change added clarifying comment --- src/EPPlus/Core/RangeCopyHelper.cs | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/EPPlus/Core/RangeCopyHelper.cs b/src/EPPlus/Core/RangeCopyHelper.cs index 78e84dbc99..e6fddb18b6 100644 --- a/src/EPPlus/Core/RangeCopyHelper.cs +++ b/src/EPPlus/Core/RangeCopyHelper.cs @@ -289,6 +289,8 @@ private void CopyDataValidations() string newAddress = ""; if (dv.Address.Addresses == null) { + //Get the range of actual validations within the source range + //As the source range can include empty data etc. newAddress = HandleAddress(dv.Address); } else @@ -412,8 +414,8 @@ private string HandleAddress(ExcelAddressBase inAddress) var colOffset = address._fromCol - _sourceRange._fromCol; var fr = Math.Min(Math.Max(_destinationRange._fromRow + rowOffset, 1), ExcelPackage.MaxRows); var fc = Math.Min(Math.Max(_destinationRange._fromCol + colOffset, 1), ExcelPackage.MaxColumns); - address = EnumUtil.HasFlag(_copyOptions, ExcelRangeCopyOptionFlags.Transpose) ? new ExcelAddressBase(fc, fr, Math.Min(fc + _destinationRange.Columns - 1, ExcelPackage.MaxColumns), Math.Min(fr + _destinationRange.Rows - 1, ExcelPackage.MaxRows)) : - new ExcelAddressBase(fr, fc, Math.Min(fr + _destinationRange.Rows-1, ExcelPackage.MaxRows), Math.Min(fc + _destinationRange.Columns-1, ExcelPackage.MaxColumns)); + address = EnumUtil.HasFlag(_copyOptions, ExcelRangeCopyOptionFlags.Transpose) ? new ExcelAddressBase(fc, fr, Math.Min(fc + address.Columns - 1, ExcelPackage.MaxColumns), Math.Min(fr + address.Rows - 1, ExcelPackage.MaxRows)) : + new ExcelAddressBase(fr, fc, Math.Min(fr + address.Rows-1, ExcelPackage.MaxRows), Math.Min(fc + address.Columns-1, ExcelPackage.MaxColumns)); return address.Address; } return ""; From b076360c48d3475b3bec3fb3c4d821feaf3ea95f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ossian=20Edstr=C3=B6m?= Date: Tue, 20 Oct 2026 09:42:44 +0200 Subject: [PATCH 6/7] Fixed typo 'Collition' to 'Collision' --- .../ExcelConditionalFormattingBeginsWith.cs | 2 +- .../ExcelConditionalFormattingContainsText.cs | 2 +- .../ExcelConditionalFormattingDataBar.cs | 2 +- .../ExcelConditionalFormattingEndsWith.cs | 2 +- .../Rules/ExcelConditionalFormattingEqual.cs | 2 +- ...celConditionalFormattingNotContainsText.cs | 2 +- .../ExcelConditionalFormattingNotEqual.cs | 2 +- ...celConditionalFormattingTimePeriodGroup.cs | 2 +- ...ExcelConditionalFormattingTwoColorScale.cs | 2 +- src/EPPlus/Core/AutofitHelper.cs | 2 +- src/EPPlus/Core/RangeCopyHelper.cs | 14 +++++----- .../Worksheet/FormulaDataTableValidation.cs | 2 +- .../Worksheet/WorksheetRangeDeleteHelper.cs | 18 ++++++------- .../Core/Worksheet/WorksheetRangeHelper.cs | 12 ++++----- .../Worksheet/WorksheetRangeInsertHelper.cs | 16 ++++++------ .../ExcelDataValidationCollection.cs | 6 ++--- src/EPPlus/Drawing/Chart/ExcelChartSerie.cs | 4 +-- src/EPPlus/ExcelAddressBase.cs | 22 ++++++++-------- src/EPPlus/ExcelAddressCollideUtility.cs | 20 +++++++------- src/EPPlus/ExcelCellBase.cs | 2 +- src/EPPlus/ExcelRangeBase.cs | 18 ++++++------- src/EPPlus/ExcelWorksheet.cs | 2 +- src/EPPlus/ExcelWorksheetView.cs | 4 +-- .../Export/HtmlExport/ExporterContext.cs | 2 +- .../DependencyChain/RpnFormulaExecution.cs | 6 ++--- .../Functions/RefAndLookup/GetPivotData.cs | 2 +- .../LexicalAnalysis/FormulaAddress.cs | 2 +- src/EPPlus/Table/ExcelTable.cs | 4 +-- src/EPPlus/Table/ExcelTableCollection.cs | 4 +-- .../PivotTable/ExcelPivotTableCollection.cs | 4 +-- src/EPPlus/Utils/AddressUtility.cs | 4 +-- .../Core/Range/Insert/RangeInsertTests.cs | 26 +++++++++---------- .../DataValidation/DataValidationTests.cs | 2 +- .../ExcelUtilities/RangeAddressTests.cs | 6 ++--- 34 files changed, 111 insertions(+), 111 deletions(-) diff --git a/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingBeginsWith.cs b/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingBeginsWith.cs index 718a1f4cd7..98b42a578c 100644 --- a/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingBeginsWith.cs +++ b/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingBeginsWith.cs @@ -154,7 +154,7 @@ public override ExcelAddress Address internal override bool ShouldApplyToCell(ExcelAddress address) { - if (Address.Collide(address) != ExcelAddressBase.eAddressCollition.No) + if (Address.Collide(address) != ExcelAddressBase.eAddressCollision.No) { if (_ws.Cells[address.Start.Address].Value != null) { diff --git a/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingContainsText.cs b/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingContainsText.cs index d8f5fc48ed..ca4f599ab0 100644 --- a/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingContainsText.cs +++ b/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingContainsText.cs @@ -127,7 +127,7 @@ void UpdateFormula() } internal override bool ShouldApplyToCell(ExcelAddress address) { - if(Address.Collide(address) != ExcelAddressBase.eAddressCollition.No) + if(Address.Collide(address) != ExcelAddressBase.eAddressCollision.No) { var val = _ws.Cells[address.Start.Address].Value; var stringValue = val == null ? "" : val.ToString(); diff --git a/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingDataBar.cs b/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingDataBar.cs index 7a1ef8f05f..1600dc50f4 100644 --- a/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingDataBar.cs +++ b/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingDataBar.cs @@ -316,7 +316,7 @@ public Color Color internal override bool ShouldApplyToCell(ExcelAddress address) { - if (Address.Collide(address) != ExcelAddressBase.eAddressCollition.No) + if (Address.Collide(address) != ExcelAddressBase.eAddressCollision.No) { var cellValue = _ws.Cells[address.Address].Value; diff --git a/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingEndsWith.cs b/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingEndsWith.cs index 7079ccaa00..8d0eec6e8c 100644 --- a/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingEndsWith.cs +++ b/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingEndsWith.cs @@ -155,7 +155,7 @@ void UpdateFormula() internal override bool ShouldApplyToCell(ExcelAddress address) { - if (Address.Collide(address) != ExcelAddressBase.eAddressCollition.No) + if (Address.Collide(address) != ExcelAddressBase.eAddressCollision.No) { if(_ws.Cells[address.Start.Address].Value != null) { diff --git a/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingEqual.cs b/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingEqual.cs index 072e121a89..13465d3633 100644 --- a/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingEqual.cs +++ b/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingEqual.cs @@ -55,7 +55,7 @@ internal ExcelConditionalFormattingEqual(ExcelConditionalFormattingEqual copy, E internal override bool ShouldApplyToCell(ExcelAddress address) { - if (Address.Collide(address) != ExcelAddressBase.eAddressCollition.No) + if (Address.Collide(address) != ExcelAddressBase.eAddressCollision.No) { if (_ws.Cells[address.Start.Address].Value != null && string.IsNullOrEmpty(Formula) == false) { diff --git a/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingNotContainsText.cs b/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingNotContainsText.cs index 349cc510d7..3efcdc6c61 100644 --- a/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingNotContainsText.cs +++ b/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingNotContainsText.cs @@ -117,7 +117,7 @@ void UpdateFormula() internal override bool ShouldApplyToCell(ExcelAddress address) { - if (Address.Collide(address) != ExcelAddressBase.eAddressCollition.No) + if (Address.Collide(address) != ExcelAddressBase.eAddressCollision.No) { //Formula2 only filled if there's a cell or formula to cond if (_ws.Cells[address.Start.Address].Value != null) diff --git a/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingNotEqual.cs b/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingNotEqual.cs index 1b412e4598..f6cbfbacee 100644 --- a/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingNotEqual.cs +++ b/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingNotEqual.cs @@ -60,7 +60,7 @@ internal override ExcelConditionalFormattingRule Clone(ExcelWorksheet newWs = nu internal override bool ShouldApplyToCell(ExcelAddress address) { - if (Address.Collide(address) != ExcelAddressBase.eAddressCollition.No) + if (Address.Collide(address) != ExcelAddressBase.eAddressCollision.No) { if (_ws.Cells[address.Start.Address].Value != null && string.IsNullOrEmpty(Formula) == false) { diff --git a/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingTimePeriodGroup.cs b/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingTimePeriodGroup.cs index 66540e9ca2..d80c0eed2d 100644 --- a/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingTimePeriodGroup.cs +++ b/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingTimePeriodGroup.cs @@ -67,7 +67,7 @@ internal override ExcelConditionalFormattingRule Clone(ExcelWorksheet newWs = nu internal override bool ShouldApplyToCell(ExcelAddress address) { - if (Address.Collide(address) != ExcelAddressBase.eAddressCollition.No) + if (Address.Collide(address) != ExcelAddressBase.eAddressCollision.No) { if (_ws.Cells[address.Start.Address].Value != null && ConvertUtil.IsNumericOrDate(_ws.Cells[address.Start.Address].Value)) { diff --git a/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingTwoColorScale.cs b/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingTwoColorScale.cs index b1fb2eab1c..3b1f85d558 100644 --- a/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingTwoColorScale.cs +++ b/src/EPPlus/ConditionalFormatting/Rules/ExcelConditionalFormattingTwoColorScale.cs @@ -258,7 +258,7 @@ internal virtual string ApplyStyleOverride(ExcelAddress address) internal override bool ShouldApplyToCell(ExcelAddress address) { - if (Address.Collide(address) != ExcelAddressBase.eAddressCollition.No) + if (Address.Collide(address) != ExcelAddressBase.eAddressCollision.No) { var cellValue = _ws.Cells[address.Address].Value; diff --git a/src/EPPlus/Core/AutofitHelper.cs b/src/EPPlus/Core/AutofitHelper.cs index 73a57e4470..3907e2ff69 100644 --- a/src/EPPlus/Core/AutofitHelper.cs +++ b/src/EPPlus/Core/AutofitHelper.cs @@ -126,7 +126,7 @@ internal void AutofitColumn(double MinimumWidth, double MaximumWidth) Dictionary textLengthCache = new Dictionary(); foreach (var af in afAddr) { - if (af.Collide(fromRow, col, toRow, col) != eAddressCollition.No) + if (af.Collide(fromRow, col, toRow, col) != eAddressCollision.No) { var cell = worksheet.Cells[af._fromRow, col]; var cellStyleId = styles.CellXfs[cell.StyleID]; diff --git a/src/EPPlus/Core/RangeCopyHelper.cs b/src/EPPlus/Core/RangeCopyHelper.cs index e6fddb18b6..5943587842 100644 --- a/src/EPPlus/Core/RangeCopyHelper.cs +++ b/src/EPPlus/Core/RangeCopyHelper.cs @@ -195,8 +195,8 @@ private void CopyPivotTables() foreach (var table in _sourceRange.Worksheet.PivotTables) { var ac = _sourceRange.Collide(table.Address); - if (ac == eAddressCollition.Inside || - ac == eAddressCollition.Equal) + if (ac == eAddressCollision.Inside || + ac == eAddressCollision.Equal) { tablesToCopy.Add(table); } @@ -210,8 +210,8 @@ private void CopyTables() foreach(var table in _sourceRange.Worksheet.Tables) { var ac = _sourceRange.Collide(table.Range); - if (ac == eAddressCollition.Inside || - ac == eAddressCollition.Equal) + if (ac == eAddressCollision.Inside || + ac == eAddressCollision.Equal) { tablesToCopy.Add(table); } @@ -407,7 +407,7 @@ private string HandleAddress(ExcelAddressBase inAddress) if (inAddress == null) return ""; } } - if (inAddress.Collide(_sourceRange) != eAddressCollition.No) + if (inAddress.Collide(_sourceRange) != eAddressCollision.No) { var address = _sourceRange.Intersect(inAddress); var rowOffset = address._fromRow - _sourceRange._fromRow; @@ -882,9 +882,9 @@ private Dictionary GetCopiedMergedCells() { var adr = new ExcelAddress(worksheet.Name, worksheet.MergedCells._list[csem.Value]); var collideResult = _sourceRange.Collide(adr); - if (collideResult != eAddressCollition.No) + if (collideResult != eAddressCollision.No) { - if(collideResult == eAddressCollition.Partly) + if(collideResult == eAddressCollision.Partly) { //Partial merge of the address take only if more than one cell intersects. var intersectingCells = _sourceRange.Intersect(adr); diff --git a/src/EPPlus/Core/Worksheet/FormulaDataTableValidation.cs b/src/EPPlus/Core/Worksheet/FormulaDataTableValidation.cs index 177d77f19b..e1d95fe4c0 100644 --- a/src/EPPlus/Core/Worksheet/FormulaDataTableValidation.cs +++ b/src/EPPlus/Core/Worksheet/FormulaDataTableValidation.cs @@ -36,7 +36,7 @@ internal static void HasPartlyFormulaDataTable(ExcelWorksheet ws, ExcelAddressBa fa._fromCol--; } - if (deleteRange.Collide(fa)==ExcelAddressBase.eAddressCollition.Partly) + if (deleteRange.Collide(fa)==ExcelAddressBase.eAddressCollision.Partly) { throw new InvalidOperationException(errorMsg); } diff --git a/src/EPPlus/Core/Worksheet/WorksheetRangeDeleteHelper.cs b/src/EPPlus/Core/Worksheet/WorksheetRangeDeleteHelper.cs index c9f8285419..0516a8e002 100644 --- a/src/EPPlus/Core/Worksheet/WorksheetRangeDeleteHelper.cs +++ b/src/EPPlus/Core/Worksheet/WorksheetRangeDeleteHelper.cs @@ -450,7 +450,7 @@ private static void DeleteSparkLinesAddress(ExcelRangeBase range, eShiftTypeDele var delSparklineGroups = new List(); foreach (var slg in range.Worksheet.SparklineGroups) { - if (slg.DateAxisRange != null && effectedAddress.Collide(slg.DateAxisRange) >= ExcelAddressBase.eAddressCollition.Inside) + if (slg.DateAxisRange != null && effectedAddress.Collide(slg.DateAxisRange) >= ExcelAddressBase.eAddressCollision.Inside) { string address; if (shift == eShiftTypeDelete.Up) @@ -468,13 +468,13 @@ private static void DeleteSparkLinesAddress(ExcelRangeBase range, eShiftTypeDele var delSparklines = new List(); foreach (var sl in slg.Sparklines) { - if (range.Collide(sl.Cell.Row, sl.Cell.Column) >= ExcelAddressBase.eAddressCollition.Inside) + if (range.Collide(sl.Cell.Row, sl.Cell.Column) >= ExcelAddressBase.eAddressCollision.Inside) { delSparklines.Add(sl); } else if (shift == eShiftTypeDelete.Up) { - if (effectedAddress.Collide(sl.RangeAddress) >= ExcelAddressBase.eAddressCollition.Inside || + if (effectedAddress.Collide(sl.RangeAddress) >= ExcelAddressBase.eAddressCollision.Inside || range.CollideFullRow(sl.RangeAddress._fromRow, sl.RangeAddress._toRow)) { sl.RangeAddress = sl.RangeAddress.DeleteRow(range._fromRow, range.Rows); @@ -487,7 +487,7 @@ private static void DeleteSparkLinesAddress(ExcelRangeBase range, eShiftTypeDele } else { - if (effectedAddress.Collide(sl.RangeAddress) >= ExcelAddressBase.eAddressCollition.Inside + if (effectedAddress.Collide(sl.RangeAddress) >= ExcelAddressBase.eAddressCollision.Inside || range.CollideFullColumn(sl.RangeAddress._fromCol, sl.RangeAddress._toCol)) { @@ -512,10 +512,10 @@ private static void DeleteSparkLinesAddress(ExcelRangeBase range, eShiftTypeDele private static void DeleteFilterAddress(ExcelRangeBase range, ExcelAddressBase effectedAddress, eShiftTypeDelete shift) { var ws = range.Worksheet; - if (ws.AutoFilter.Address != null && effectedAddress.Collide(ws.AutoFilter.Address) != ExcelAddressBase.eAddressCollition.No) + if (ws.AutoFilter.Address != null && effectedAddress.Collide(ws.AutoFilter.Address) != ExcelAddressBase.eAddressCollision.No) { var firstRow = new ExcelAddress(ws.AutoFilter.Address._fromRow, ws.AutoFilter.Address._fromCol, ws.AutoFilter.Address._fromRow, ws.AutoFilter.Address._toCol); - if (range.Collide(firstRow, true) >= ExcelAddressBase.eAddressCollition.Inside) + if (range.Collide(firstRow, true) >= ExcelAddressBase.eAddressCollision.Inside) { ws.AutoFilter.Address = null; } @@ -671,7 +671,7 @@ private static ExcelAddressBase DeleteSplitIndividualAddress(ExcelAddressBase ad else { var collide = affectedAddress.Collide(address); - if (collide == ExcelAddressBase.eAddressCollition.Partly) + if (collide == ExcelAddressBase.eAddressCollision.Partly) { var addressToShift = ShiftAddress(address, affectedAddress, deleteRange, shift); @@ -701,7 +701,7 @@ private static ExcelAddressBase DeleteSplitIndividualAddress(ExcelAddressBase ad } return new ExcelAddressBase(newAddress.Substring(0, newAddress.Length - 1)); } - else if (collide != ExcelAddressBase.eAddressCollition.No) + else if (collide != ExcelAddressBase.eAddressCollision.No) { return ShiftAddress(address, affectedAddress, deleteRange, shift); } @@ -833,7 +833,7 @@ private static void FixFormulasDelete(ExcelRangeBase range, ExcelAddressBase eff { if (workSheetName == ws.Name) { - if (effectedRange.Collide(new ExcelAddressBase(sf.Address)) != ExcelAddressBase.eAddressCollition.No) + if (effectedRange.Collide(new ExcelAddressBase(sf.Address)) != ExcelAddressBase.eAddressCollision.No) { ExcelAddressBase a; if (shift == eShiftTypeDelete.Up) diff --git a/src/EPPlus/Core/Worksheet/WorksheetRangeHelper.cs b/src/EPPlus/Core/Worksheet/WorksheetRangeHelper.cs index 3d60f85fd7..5152648cc7 100644 --- a/src/EPPlus/Core/Worksheet/WorksheetRangeHelper.cs +++ b/src/EPPlus/Core/Worksheet/WorksheetRangeHelper.cs @@ -297,7 +297,7 @@ private static bool ConvertEffectedSharedFormulaIfReferenceWithinRange(ExcelWork if (tokenAddress._toRowFixed == false) tokenAddress._toRow += (sfAddress.Rows - 1); //Extend the token address for all rows in the formula and check for collitions with the deleted range. if (tokenAddress._toColFixed == false) tokenAddress._toCol += (sfAddress.Columns - 1); //Extend the token address for all columns in the formula and check for collition with the deleted range. - if (tokenAddress.Collide(range, true) != ExcelAddressBase.eAddressCollition.No) //Shared Formula address is effected. + if (tokenAddress.Collide(range, true) != ExcelAddressBase.eAddressCollision.No) //Shared Formula address is effected. { doConvertSF = true; break; @@ -337,7 +337,7 @@ internal static void ValidateIfInsertDeleteIsPossible(ExcelRangeBase range, Exce { //Validate autofilter if (range.Worksheet.AutoFilter.Address!=null && - effectedAddress.Collide(range.Worksheet.AutoFilter.Address) == ExcelAddressBase.eAddressCollition.Partly + effectedAddress.Collide(range.Worksheet.AutoFilter.Address) == ExcelAddressBase.eAddressCollision.Partly && range.Worksheet.AutoFilter.Address.CollideFullRowOrColumn(range) == false) { @@ -350,7 +350,7 @@ internal static void ValidateIfInsertDeleteIsPossible(ExcelRangeBase range, Exce if (!string.IsNullOrEmpty(a)) { var mc = new ExcelAddressBase(a); - if (effectedAddress.Collide(mc) == ExcelAddressBase.eAddressCollition.Partly) + if (effectedAddress.Collide(mc) == ExcelAddressBase.eAddressCollision.Partly) { throw new InvalidOperationException($"Can't {(insert ? "insert into" : "delete from")} the range. Cells collide with merged range {a}"); } @@ -360,7 +360,7 @@ internal static void ValidateIfInsertDeleteIsPossible(ExcelRangeBase range, Exce //Validate pivot tables Cells foreach (var pt in range.Worksheet.PivotTables) { - if (effectedAddress.Collide(pt.Address) == ExcelAddressBase.eAddressCollition.Partly) + if (effectedAddress.Collide(pt.Address) == ExcelAddressBase.eAddressCollision.Partly) { throw new InvalidOperationException($"Can't {(insert ? "insert into" : "delete from")} the range. Cells collide with pivot table {pt.Name}"); } @@ -369,8 +369,8 @@ internal static void ValidateIfInsertDeleteIsPossible(ExcelRangeBase range, Exce //Validate tables Cells foreach (var t in range.Worksheet.Tables) { - if (effectedAddressTable.Collide(t.Address) == ExcelAddressBase.eAddressCollition.Partly && - effectedAddress.Collide(t.Address) != ExcelAddressBase.eAddressCollition.No) + if (effectedAddressTable.Collide(t.Address) == ExcelAddressBase.eAddressCollision.Partly && + effectedAddress.Collide(t.Address) != ExcelAddressBase.eAddressCollision.No) { throw new InvalidOperationException($"Can't {(insert ? "insert into" : "delete from")} the range. Cells collide with table {t.Name}"); } diff --git a/src/EPPlus/Core/Worksheet/WorksheetRangeInsertHelper.cs b/src/EPPlus/Core/Worksheet/WorksheetRangeInsertHelper.cs index a3978c73d6..7e4283e3b6 100644 --- a/src/EPPlus/Core/Worksheet/WorksheetRangeInsertHelper.cs +++ b/src/EPPlus/Core/Worksheet/WorksheetRangeInsertHelper.cs @@ -334,7 +334,7 @@ private static void InsertDataValidation(ExcelRangeBase range, eShiftTypeInsert private static void InsertFilterAddress(ExcelRangeBase range, ExcelAddressBase effectedAddress, eShiftTypeInsert shift) { var ws = range.Worksheet; - if (ws.AutoFilter.Address != null && effectedAddress.Collide(ws.AutoFilter.Address) != ExcelAddressBase.eAddressCollition.No) + if (ws.AutoFilter.Address != null && effectedAddress.Collide(ws.AutoFilter.Address) != ExcelAddressBase.eAddressCollision.No) { if(shift==eShiftTypeInsert.Down) { @@ -350,7 +350,7 @@ private static void InsertSparkLinesAddress(ExcelRangeBase range, eShiftTypeInse { foreach (var slg in range.Worksheet.SparklineGroups) { - if (slg.DateAxisRange!=null && effectedAddress.Collide(slg.DateAxisRange) >= ExcelAddressBase.eAddressCollition.Inside) + if (slg.DateAxisRange!=null && effectedAddress.Collide(slg.DateAxisRange) >= ExcelAddressBase.eAddressCollision.Inside) { string address; if (shift == eShiftTypeInsert.Down) @@ -368,7 +368,7 @@ private static void InsertSparkLinesAddress(ExcelRangeBase range, eShiftTypeInse { if (shift == eShiftTypeInsert.Down) { - if (effectedAddress.Collide(sl.RangeAddress) >= ExcelAddressBase.eAddressCollition.Inside || + if (effectedAddress.Collide(sl.RangeAddress) >= ExcelAddressBase.eAddressCollision.Inside || range.CollideFullRow(sl.RangeAddress._fromRow, sl.RangeAddress._toRow)) { sl.RangeAddress = sl.RangeAddress.AddRow(range._fromRow, range.Rows); @@ -381,7 +381,7 @@ private static void InsertSparkLinesAddress(ExcelRangeBase range, eShiftTypeInse } else { - if (effectedAddress.Collide(sl.RangeAddress) >= ExcelAddressBase.eAddressCollition.Inside || + if (effectedAddress.Collide(sl.RangeAddress) >= ExcelAddressBase.eAddressCollision.Inside || range.CollideFullColumn(sl.RangeAddress._fromCol, sl.RangeAddress._toCol)) { sl.RangeAddress = sl.RangeAddress.AddColumn(range._fromCol, range.Columns); @@ -435,7 +435,7 @@ private static ExcelAddressBase InsertSplitIndividualAddress(ExcelAddressBase ad else { var collide = effectedAddress.Collide(address); - if (collide == ExcelAddressBase.eAddressCollition.Partly) + if (collide == ExcelAddressBase.eAddressCollision.Partly) { var newAddress = ""; if (shift == eShiftTypeInsert.Down) @@ -476,7 +476,7 @@ private static ExcelAddressBase InsertSplitIndividualAddress(ExcelAddressBase ad } return new ExcelAddressBase(newAddress.Substring(0, newAddress.Length - 1)); } - else if (collide != ExcelAddressBase.eAddressCollition.No) + else if (collide != ExcelAddressBase.eAddressCollision.No) { return ShiftAddress(address, range, shift); } @@ -756,11 +756,11 @@ private static void AdjustFormulasInsert(ExcelRangeBase range, ExcelAddressBase { var a = new ExcelAddressBase(f.Address); var c = effectedAddress.Collide(a); - if (c == ExcelAddressBase.eAddressCollition.Partly && (effectedAddress._fromCol > a._fromCol || effectedAddress._toCol < a._toCol)) + if (c == ExcelAddressBase.eAddressCollision.Partly && (effectedAddress._fromCol > a._fromCol || effectedAddress._toCol < a._toCol)) { throw new Exception("Invalid shared formula"); //This should never happend! } - if (f.StartCol >= columnFrom && c != ExcelAddressBase.eAddressCollition.No) + if (f.StartCol >= columnFrom && c != ExcelAddressBase.eAddressCollision.No) { if ((shift == eShiftTypeInsert.Down || shift == eShiftTypeInsert.EntireRow)) { diff --git a/src/EPPlus/DataValidation/ExcelDataValidationCollection.cs b/src/EPPlus/DataValidation/ExcelDataValidationCollection.cs index a27d0df898..2cb442192a 100644 --- a/src/EPPlus/DataValidation/ExcelDataValidationCollection.cs +++ b/src/EPPlus/DataValidation/ExcelDataValidationCollection.cs @@ -221,7 +221,7 @@ private void ValidateAddress(string address, IExcelDataValidation validatingVali continue; } var result = validation.Address.Collide(newAddress); - if (result != ExcelAddressBase.eAddressCollition.No) + if (result != ExcelAddressBase.eAddressCollision.No) { throw new InvalidOperationException(string.Format("The address ({0}) collides with an existing validation ({1})", address, validation.Address.Address)); } @@ -422,7 +422,7 @@ public IExcelDataValidation this[string address] { foreach (var a in x.Address.Addresses) { - if(a.Collide(searchedAddress) != ExcelAddressBase.eAddressCollition.No) + if(a.Collide(searchedAddress) != ExcelAddressBase.eAddressCollision.No) { return true; } @@ -431,7 +431,7 @@ public IExcelDataValidation this[string address] } else { - return x.Address.Collide(searchedAddress) != ExcelAddressBase.eAddressCollition.No; + return x.Address.Collide(searchedAddress) != ExcelAddressBase.eAddressCollision.No; } }); } diff --git a/src/EPPlus/Drawing/Chart/ExcelChartSerie.cs b/src/EPPlus/Drawing/Chart/ExcelChartSerie.cs index 7bf436518f..2af5fb3350 100644 --- a/src/EPPlus/Drawing/Chart/ExcelChartSerie.cs +++ b/src/EPPlus/Drawing/Chart/ExcelChartSerie.cs @@ -106,7 +106,7 @@ string UpdateAddressStringDelete(string address, int from, int numToDelete, Exce if (ExcelCellBase.IsValidAddress(address)) { var addressBase = new ExcelAddressBase(address); - if (address != null && affectedRange.Collide(addressBase) != ExcelAddressBase.eAddressCollition.No) + if (address != null && affectedRange.Collide(addressBase) != ExcelAddressBase.eAddressCollision.No) { if (insertType == eShiftTypeDelete.Left) { @@ -139,7 +139,7 @@ string UpdateAddressString(string address, int from, int numToAdd, ExcelAddressB if (ExcelCellBase.IsValidAddress(address)) { var addressBase = new ExcelAddressBase(address); - if (address != null && affectedRange.Collide(addressBase) != ExcelAddressBase.eAddressCollition.No) + if (address != null && affectedRange.Collide(addressBase) != ExcelAddressBase.eAddressCollision.No) { if(insertType == eShiftTypeInsert.Right) { diff --git a/src/EPPlus/ExcelAddressBase.cs b/src/EPPlus/ExcelAddressBase.cs index edc04b4d8e..84715bac51 100644 --- a/src/EPPlus/ExcelAddressBase.cs +++ b/src/EPPlus/ExcelAddressBase.cs @@ -37,7 +37,7 @@ public class ExcelAddressBase : ExcelCellBase internal string _ws; internal string _address; - internal enum eAddressCollition + internal enum eAddressCollision { No, Partly, @@ -434,8 +434,8 @@ internal ExcelAddressBase IntersectReversed(ExcelAddressBase address) internal bool IsInside(ExcelAddressBase effectedAddress) { var c = Collide(effectedAddress); - return c == ExcelAddressBase.eAddressCollition.Equal || - c == ExcelAddressBase.eAddressCollition.Inside; + return c == ExcelAddressBase.eAddressCollision.Equal || + c == ExcelAddressBase.eAddressCollision.Inside; } /// /// Address is an defined name @@ -1088,39 +1088,39 @@ private void HandleBrackets(string first, string second, List bracketPar } } #region Address manipulation methods - internal eAddressCollition Collide(ExcelAddressBase address, bool ignoreWs = false) + internal eAddressCollision Collide(ExcelAddressBase address, bool ignoreWs = false) { if (ignoreWs == false && address.WorkSheetName != WorkSheetName && string.IsNullOrEmpty(address.WorkSheetName) == false && string.IsNullOrEmpty(WorkSheetName) == false) { - return eAddressCollition.No; + return eAddressCollision.No; } return Collide(address._fromRow, address._fromCol, address._toRow, address._toCol); } - internal eAddressCollition Collide(int row, int col) + internal eAddressCollision Collide(int row, int col) { return Collide(row, col, row, col); } - internal eAddressCollition Collide(int fromRow, int fromCol, int toRow, int toCol) + internal eAddressCollision Collide(int fromRow, int fromCol, int toRow, int toCol) { if (DoNotCollide(fromRow, fromCol, toRow, toCol)) { - return eAddressCollition.No; + return eAddressCollision.No; } else if (fromRow == _fromRow && fromCol == _fromCol && toRow == _toRow && toCol == _toCol) { - return eAddressCollition.Equal; + return eAddressCollision.Equal; } else if (fromRow >= _fromRow && toRow <= _toRow && fromCol >= _fromCol && toCol <= _toCol) { - return eAddressCollition.Inside; + return eAddressCollision.Inside; } else - return eAddressCollition.Partly; + return eAddressCollision.Partly; } internal bool DoNotCollide(int fromRow, int fromCol, int toRow, int toCol) diff --git a/src/EPPlus/ExcelAddressCollideUtility.cs b/src/EPPlus/ExcelAddressCollideUtility.cs index 2f79f9dc23..8455fe8283 100644 --- a/src/EPPlus/ExcelAddressCollideUtility.cs +++ b/src/EPPlus/ExcelAddressCollideUtility.cs @@ -45,19 +45,19 @@ private static string GetWsName(FormulaRangeAddress address, ParsingContext ctx) } } - internal eAddressCollition Collide(ExcelAddressBase address, bool ignoreWs = false) + internal eAddressCollision Collide(ExcelAddressBase address, bool ignoreWs = false) { if (ignoreWs == false && address.WorkSheetName != _worksheetName && string.IsNullOrEmpty(address.WorkSheetName) == false && string.IsNullOrEmpty(_worksheetName) == false) { - return eAddressCollition.No; + return eAddressCollision.No; } return Collide(address._fromRow, address._fromCol, address._toRow, address._toCol); } - internal eAddressCollition Collide(FormulaRangeAddress address, ParsingContext ctx, bool ignoreWs = false) + internal eAddressCollision Collide(FormulaRangeAddress address, ParsingContext ctx, bool ignoreWs = false) { var ws = GetWsName(address, ctx); if ((ignoreWs == false && @@ -65,34 +65,34 @@ internal eAddressCollition Collide(FormulaRangeAddress address, ParsingContext c string.IsNullOrEmpty(ws) == false && string.IsNullOrEmpty(_worksheetName) == false) || address.WorksheetIx==-1) { - return eAddressCollition.No; + return eAddressCollision.No; } return Collide(address.FromRow, address.FromCol, address.ToRow, address.ToCol); } - internal eAddressCollition Collide(int row, int col) + internal eAddressCollision Collide(int row, int col) { return Collide(row, col, row, col); } - internal eAddressCollition Collide(int fromRow, int fromCol, int toRow, int toCol) + internal eAddressCollision Collide(int fromRow, int fromCol, int toRow, int toCol) { if (DoNotCollide(fromRow, fromCol, toRow, toCol)) { - return eAddressCollition.No; + return eAddressCollision.No; } else if (fromRow == _fromRow && fromCol == _fromCol && toRow == _toRow && toCol == _toCol) { - return eAddressCollition.Equal; + return eAddressCollision.Equal; } else if (fromRow >= _fromRow && toRow <= _toRow && fromCol >= _fromCol && toCol <= _toCol) { - return eAddressCollition.Inside; + return eAddressCollision.Inside; } else - return eAddressCollition.Partly; + return eAddressCollision.Partly; } internal bool DoNotCollide(int fromRow, int fromCol, int toRow, int toCol) diff --git a/src/EPPlus/ExcelCellBase.cs b/src/EPPlus/ExcelCellBase.cs index ec0e926fd4..775f3ca7eb 100644 --- a/src/EPPlus/ExcelCellBase.cs +++ b/src/EPPlus/ExcelCellBase.cs @@ -1217,7 +1217,7 @@ private static string UpdateFormulaReferencesPrivate(string formula, ExcelAddres { var address = new ExcelAddressBase(t.Value); if (((!string.IsNullOrEmpty(address._wb) || !IsReferencesModifiedWorksheet(currentSheet, modifiedSheet, adrWs)) && !setFixed) || - address.Collide(effectedRange) == ExcelAddressBase.eAddressCollition.No) + address.Collide(effectedRange) == ExcelAddressBase.eAddressCollision.No) { f += address.Address; continue; diff --git a/src/EPPlus/ExcelRangeBase.cs b/src/EPPlus/ExcelRangeBase.cs index bdfd27065d..f9f4f873b5 100644 --- a/src/EPPlus/ExcelRangeBase.cs +++ b/src/EPPlus/ExcelRangeBase.cs @@ -1249,7 +1249,7 @@ private void ValidateMergePossible() { foreach (var t in _worksheet.Tables) { - if (Collide(t.Address) != eAddressCollition.No) + if (Collide(t.Address) != eAddressCollision.No) { throw (new InvalidOperationException($"Cant merge range. The merge is within table {t.Name}")); } @@ -1284,7 +1284,7 @@ public bool AutoFilter if (_worksheet.AutoFilter.Address != null) { var c = this.Collide(_worksheet.AutoFilter.Address); - if (value == false && (c == eAddressCollition.Partly || c == eAddressCollition.No)) + if (value == false && (c == eAddressCollision.Partly || c == eAddressCollision.No)) { throw (new InvalidOperationException("Can't remove Autofilter. The current autofilter does not match selected range.")); } @@ -1320,8 +1320,8 @@ private void ValidateAutofilterDontCollide() foreach (var tbl in _worksheet.Tables) { var c = tbl.Address.Collide(this); - if (c == eAddressCollition.Equal) return; //Autofilter is on a table. - if (c != eAddressCollition.No) + if (c == eAddressCollision.Equal) return; //Autofilter is on a table. + if (c != eAddressCollision.No) { throw new InvalidOperationException($"Auto filter collides with table {tbl.Name}"); } @@ -1329,7 +1329,7 @@ private void ValidateAutofilterDontCollide() foreach (var pt in _worksheet.PivotTables) { var c = pt.Address.Collide(this); - if (c != eAddressCollition.No) + if (c != eAddressCollision.No) { throw new InvalidOperationException($"Auto filter collides with pivot table {pt.Name}"); } @@ -1694,7 +1694,7 @@ private void SplitFormulas(ExcelAddressBase address) if (id >= 0 && !formulas.Contains(id)) { if (_worksheet._sharedFormulas[id].FormulaType == FormulaType.Array && - Collide(_worksheet.Cells[_worksheet._sharedFormulas[id].Address]) == eAddressCollition.Partly) //If the formula is an array formula and its on the inside the overwriting range throw an exception + Collide(_worksheet.Cells[_worksheet._sharedFormulas[id].Address]) == eAddressCollision.Partly) //If the formula is an array formula and its on the inside the overwriting range throw an exception { throw (new InvalidOperationException("Cannot overwrite a part of an array-formula")); } @@ -1720,14 +1720,14 @@ private void SplitFormula(ExcelAddressBase address, int ix) var collide = address.Collide(fRange); //The formula is inside the currenct range, remove it - if (collide == eAddressCollition.Equal || collide == eAddressCollition.Inside) + if (collide == eAddressCollision.Equal || collide == eAddressCollision.Inside) { _worksheet._sharedFormulas.Remove(ix); return; //fRange.SetSharedFormulaID(int.MinValue); } var firstCellCollide = address.Collide(new ExcelAddressBase(fRange._fromRow, fRange._fromCol, fRange._fromRow, fRange._fromCol)); - if (collide == eAddressCollition.Partly && (firstCellCollide == eAddressCollition.Inside || firstCellCollide == eAddressCollition.Equal)) //Do we need to split? Only if the functions first row is inside the new range. + if (collide == eAddressCollision.Partly && (firstCellCollide == eAddressCollision.Inside || firstCellCollide == eAddressCollision.Equal)) //Do we need to split? Only if the functions first row is inside the new range. { //The formula partly collides with the current range bool fIsSet = false; @@ -1856,7 +1856,7 @@ private void ClearTableFormulas() //Clear any calculated formulas in tables. foreach (var table in Worksheet.Tables) { - if (table.Address.Collide(this) != eAddressCollition.No) + if (table.Address.Collide(this) != eAddressCollision.No) { foreach (var col in table.Columns) { diff --git a/src/EPPlus/ExcelWorksheet.cs b/src/EPPlus/ExcelWorksheet.cs index a6cda500bb..77be134a53 100644 --- a/src/EPPlus/ExcelWorksheet.cs +++ b/src/EPPlus/ExcelWorksheet.cs @@ -286,7 +286,7 @@ internal void Clear(ExcelAddressBase Destination) if (!used.Contains(v) && _list[v] != null) { var adr = new ExcelAddressBase(_list[v]); - if (!(Destination.Collide(adr) == ExcelAddressBase.eAddressCollition.Inside || Destination.Collide(adr) == ExcelAddressBase.eAddressCollition.Equal)) + if (!(Destination.Collide(adr) == ExcelAddressBase.eAddressCollision.Inside || Destination.Collide(adr) == ExcelAddressBase.eAddressCollision.Equal)) { throw (new InvalidOperationException(string.Format("Can't delete/overwrite merged cells. A range is partly merged with the another merged range. {0}", adr._address))); } diff --git a/src/EPPlus/ExcelWorksheetView.cs b/src/EPPlus/ExcelWorksheetView.cs index ee462c909b..4df337e90a 100644 --- a/src/EPPlus/ExcelWorksheetView.cs +++ b/src/EPPlus/ExcelWorksheetView.cs @@ -398,7 +398,7 @@ public ExcelWorksheetViewPaneSettings PaneSettings private bool IsActiveCellInSelection(ExcelAddressBase ac, ExcelAddressBase sd) { var c = sd.Collide(ac); - if (c == ExcelAddressBase.eAddressCollition.Equal || c == ExcelAddressBase.eAddressCollition.Inside) + if (c == ExcelAddressBase.eAddressCollision.Equal || c == ExcelAddressBase.eAddressCollision.Inside) { return true; } @@ -409,7 +409,7 @@ private bool IsActiveCellInSelection(ExcelAddressBase ac, ExcelAddressBase sd) foreach (var sds in sd.Addresses) { c = sds.Collide(ac); - if (c == ExcelAddressBase.eAddressCollition.Equal || c == ExcelAddressBase.eAddressCollition.Inside) + if (c == ExcelAddressBase.eAddressCollision.Equal || c == ExcelAddressBase.eAddressCollision.Inside) { return true; } diff --git a/src/EPPlus/Export/HtmlExport/ExporterContext.cs b/src/EPPlus/Export/HtmlExport/ExporterContext.cs index ee9692577f..88e4abcba6 100644 --- a/src/EPPlus/Export/HtmlExport/ExporterContext.cs +++ b/src/EPPlus/Export/HtmlExport/ExporterContext.cs @@ -39,7 +39,7 @@ internal void InitializeQuadTree(ExcelRangeBase range) { foreach (var address in rule.Address.GetAllAddresses()) { - if (address.Collide(range) != ExcelAddressBase.eAddressCollition.No) + if (address.Collide(range) != ExcelAddressBase.eAddressCollision.No) { _cfQuadTree.Add(new QuadRange(address), rule); } diff --git a/src/EPPlus/FormulaParsing/DependencyChain/RpnFormulaExecution.cs b/src/EPPlus/FormulaParsing/DependencyChain/RpnFormulaExecution.cs index 8719458227..c75cb41765 100644 --- a/src/EPPlus/FormulaParsing/DependencyChain/RpnFormulaExecution.cs +++ b/src/EPPlus/FormulaParsing/DependencyChain/RpnFormulaExecution.cs @@ -172,14 +172,14 @@ private static void UpdateTableArrayFlag(ExcelRangeBase range) //Check table formulas that needs the array flag updated for the columns formulas. foreach (var table in range.Worksheet.Tables) { - if (table.Address.Collide(range) != eAddressCollition.No) + if (table.Address.Collide(range) != eAddressCollision.No) { foreach (var c in table.Columns) { if (string.IsNullOrEmpty(c.CalculatedColumnFormula) == false) { var ca = c.DataAddress; - if (ca.Collide(range) != eAddressCollition.No) + if (ca.Collide(range) != eAddressCollision.No) { var ma = ca.Intersect(range); c.IsCalculatedFormulaArray = IsCFArray(range.Worksheet, ma); @@ -1079,7 +1079,7 @@ private static void CheckCircularReferences(RpnOptimizedDependencyChain depChain { var sf = f._ws._sharedFormulas[f._arrayIndex]; var fa = new FormulaRangeAddress(depChain._parsingContext) { FromRow = sf.StartRow, ToRow = sf.EndRow, FromCol = sf.StartCol, ToCol = sf.EndCol, WorksheetIx = f._ws.IndexInList }; - if (fa.CollidesWith(address) != eAddressCollition.No) + if (fa.CollidesWith(address) != eAddressCollision.No) { if(!options.AllowCircularReferences) { diff --git a/src/EPPlus/FormulaParsing/Excel/Functions/RefAndLookup/GetPivotData.cs b/src/EPPlus/FormulaParsing/Excel/Functions/RefAndLookup/GetPivotData.cs index efb7efc0d6..cf13dcd1a0 100644 --- a/src/EPPlus/FormulaParsing/Excel/Functions/RefAndLookup/GetPivotData.cs +++ b/src/EPPlus/FormulaParsing/Excel/Functions/RefAndLookup/GetPivotData.cs @@ -328,7 +328,7 @@ private bool GetPivotTable(IRangeInfo ri, out ExcelPivotTable pivotTable) if (pfCount > 0) pfCount++; var ptAdr = pt.Address; var ptAddress = new ExcelAddressBase(ptAdr._fromRow <= pfCount + 1 ? 1 : ptAdr._fromRow - pfCount, ptAdr._fromCol, ptAdr._toRow, ptAdr._toCol); - if (ptAddress.Collide(adr.FromRow, adr.FromCol, adr.ToRow, adr.ToCol)!=ExcelAddressBase.eAddressCollition.No) + if (ptAddress.Collide(adr.FromRow, adr.FromCol, adr.ToRow, adr.ToCol)!=ExcelAddressBase.eAddressCollision.No) { pivotTable = pt; return true; diff --git a/src/EPPlus/FormulaParsing/LexicalAnalysis/FormulaAddress.cs b/src/EPPlus/FormulaParsing/LexicalAnalysis/FormulaAddress.cs index 4061d658c3..9e3b735d81 100644 --- a/src/EPPlus/FormulaParsing/LexicalAnalysis/FormulaAddress.cs +++ b/src/EPPlus/FormulaParsing/LexicalAnalysis/FormulaAddress.cs @@ -771,7 +771,7 @@ public static FormulaRangeAddress Empty get { return new FormulaRangeAddress(); } } - internal eAddressCollition CollidesWith(FormulaRangeAddress other) + internal eAddressCollision CollidesWith(FormulaRangeAddress other) { var util = new ExcelAddressCollideUtility(this, _context); return util.Collide(other, _context); diff --git a/src/EPPlus/Table/ExcelTable.cs b/src/EPPlus/Table/ExcelTable.cs index b4f4b07da7..013ae832cc 100644 --- a/src/EPPlus/Table/ExcelTable.cs +++ b/src/EPPlus/Table/ExcelTable.cs @@ -1506,7 +1506,7 @@ public ExcelTable Copy(ExcelRangeBase range, string newTableName) Range.Copy(range); var ws = range._worksheet; - var tblCopy = WorkSheet.Tables.FirstOrDefault(x => x.Address.Collide(range) == ExcelAddressBase.eAddressCollition.No); + var tblCopy = WorkSheet.Tables.FirstOrDefault(x => x.Address.Collide(range) == ExcelAddressBase.eAddressCollision.No); if (tblCopy != null) { tblCopy.Name = newTableName; @@ -1520,7 +1520,7 @@ public ExcelTable Copy(ExcelRangeBase range, string newTableName) public ExcelTable Copy(ExcelRangeBase range) { Range.Copy(range); - return WorkSheet.Tables.FirstOrDefault(x => x.Address.Collide(range) != ExcelAddressBase.eAddressCollition.No); + return WorkSheet.Tables.FirstOrDefault(x => x.Address.Collide(range) != ExcelAddressBase.eAddressCollision.No); } } } diff --git a/src/EPPlus/Table/ExcelTableCollection.cs b/src/EPPlus/Table/ExcelTableCollection.cs index f4d14df04b..8fe39e20a5 100644 --- a/src/EPPlus/Table/ExcelTableCollection.cs +++ b/src/EPPlus/Table/ExcelTableCollection.cs @@ -165,7 +165,7 @@ internal ExcelTable AddInternal(ExcelAddressBase Range, string name, ExcelTable foreach (var t in _tables) { - if (t.Address.Collide(Range) != ExcelAddressBase.eAddressCollition.No) + if (t.Address.Collide(Range) != ExcelAddressBase.eAddressCollision.No) { throw (new ArgumentException(string.Format("Table range collides with table {0}", t.Name))); } @@ -174,7 +174,7 @@ internal ExcelTable AddInternal(ExcelAddressBase Range, string name, ExcelTable foreach (var mc in _ws.MergedCells) { if (mc == null) continue; // Issue 780: this happens if a merged cell has been removed - if (new ExcelAddressBase(mc).Collide(Range) != ExcelAddressBase.eAddressCollition.No) + if (new ExcelAddressBase(mc).Collide(Range) != ExcelAddressBase.eAddressCollision.No) { throw (new ArgumentException($"Table range collides with merged range {mc}")); } diff --git a/src/EPPlus/Table/PivotTable/ExcelPivotTableCollection.cs b/src/EPPlus/Table/PivotTable/ExcelPivotTableCollection.cs index 779b91fd93..c9c2b98754 100644 --- a/src/EPPlus/Table/PivotTable/ExcelPivotTableCollection.cs +++ b/src/EPPlus/Table/PivotTable/ExcelPivotTableCollection.cs @@ -117,7 +117,7 @@ private void ValidateAdd(ExcelAddressBase Range, string Name) } foreach (var t in _pivotTables) { - if (t.Address.Collide(Range) != ExcelAddressBase.eAddressCollition.No) + if (t.Address.Collide(Range) != ExcelAddressBase.eAddressCollision.No) { throw (new ArgumentException(string.Format("Table range collides with table {0}", t.Name))); } @@ -334,7 +334,7 @@ public void Calculate(bool refresh = false) /// The first pivot table in the range internal ExcelPivotTable GetByAddress(ExcelRange range) { - return _pivotTables.FirstOrDefault(x => x.Address.Collide(range) != ExcelAddressBase.eAddressCollition.No); + return _pivotTables.FirstOrDefault(x => x.Address.Collide(range) != ExcelAddressBase.eAddressCollision.No); } } } diff --git a/src/EPPlus/Utils/AddressUtility.cs b/src/EPPlus/Utils/AddressUtility.cs index 134208e94c..cf92171a44 100644 --- a/src/EPPlus/Utils/AddressUtility.cs +++ b/src/EPPlus/Utils/AddressUtility.cs @@ -67,7 +67,7 @@ internal static string ShiftAddressRowsInFormula(ExcelRangeBase range, string fo var adr = GetAddressFromToken(tokens, ref i); if (adr.IsFullColumn==false) { - if (adr.Table == null && (adr.Collide(affectedRange) != ExcelAddressBase.eAddressCollition.No) && + if (adr.Table == null && (adr.Collide(affectedRange) != ExcelAddressBase.eAddressCollision.No) && ((extRef == string.Empty && ws == string.Empty) || (ws.Equals(range.WorkSheetName, StringComparison.InvariantCultureIgnoreCase) && extRef == string.Empty) || int.TryParse(extRef, out int ier) && ier == range.ExternalReferenceIndex)) @@ -139,7 +139,7 @@ internal static string ShiftAddressColumnsInFormula(ExcelRangeBase range, string var adr = GetAddressFromToken(tokens, ref i); if (adr.IsFullRow == false) { - if (adr.Table == null && (adr.Collide(affectedRange) != ExcelAddressBase.eAddressCollition.No) && + if (adr.Table == null && (adr.Collide(affectedRange) != ExcelAddressBase.eAddressCollision.No) && ((extRef == string.Empty && ws == string.Empty) || (ws.Equals(range.WorkSheetName, StringComparison.InvariantCultureIgnoreCase) && extRef == string.Empty) || int.TryParse(extRef, out int ier) && ier == range.ExternalReferenceIndex)) diff --git a/src/EPPlusTest/Core/Range/Insert/RangeInsertTests.cs b/src/EPPlusTest/Core/Range/Insert/RangeInsertTests.cs index 36c87f6161..6d455cf3ee 100644 --- a/src/EPPlusTest/Core/Range/Insert/RangeInsertTests.cs +++ b/src/EPPlusTest/Core/Range/Insert/RangeInsertTests.cs @@ -930,7 +930,7 @@ public void ValidateConditionalFormattingShiftRightBetweenCols() ws.Cells["C4:C7"].Insert(eShiftTypeInsert.Right); - Assert.AreEqual(ExcelAddressBase.eAddressCollition.Equal, cf.Address.Collide(new ExcelAddress("B2:B10,E8,F5:F7,C4:C7"))); + Assert.AreEqual(ExcelAddressBase.eAddressCollision.Equal, cf.Address.Collide(new ExcelAddress("B2:B10,E8,F5:F7,C4:C7"))); } [TestMethod] @@ -942,8 +942,8 @@ public void ValidateConditionalFormattingShiftEntireRowBetweenCols() ws.Cells["C4:C7"].Insert(eShiftTypeInsert.EntireRow); - Assert.AreEqual(ExcelAddressBase.eAddressCollition.Equal, cf.Address.Addresses[0].Collide(new ExcelAddress("B2:B14"))); - Assert.AreEqual(ExcelAddressBase.eAddressCollition.Equal, cf.Address.Addresses[1].Collide(new ExcelAddress("E9:E12"))); + Assert.AreEqual(ExcelAddressBase.eAddressCollision.Equal, cf.Address.Addresses[0].Collide(new ExcelAddress("B2:B14"))); + Assert.AreEqual(ExcelAddressBase.eAddressCollision.Equal, cf.Address.Addresses[1].Collide(new ExcelAddress("E9:E12"))); } [TestMethod] @@ -955,8 +955,8 @@ public void ValidateConditionalFormattingShiftEntireRowBetweenColsEdgeCase() ws.Cells["C6:C7"].Insert(eShiftTypeInsert.EntireRow); - Assert.AreEqual(ExcelAddressBase.eAddressCollition.Equal, cf.Address.Addresses[0].Collide(new ExcelAddress("B2:B12"))); - Assert.AreEqual(ExcelAddressBase.eAddressCollition.Equal, cf.Address.Addresses[1].Collide(new ExcelAddress("E5:E10"))); + Assert.AreEqual(ExcelAddressBase.eAddressCollision.Equal, cf.Address.Addresses[0].Collide(new ExcelAddress("B2:B12"))); + Assert.AreEqual(ExcelAddressBase.eAddressCollision.Equal, cf.Address.Addresses[1].Collide(new ExcelAddress("E5:E10"))); } [TestMethod] @@ -968,8 +968,8 @@ public void ValidateConditionalFormattingInsertSingleCell() ws.Cells["B11"].Insert(eShiftTypeInsert.Down); - Assert.AreEqual(ExcelAddressBase.eAddressCollition.Equal, cf.Address.Addresses[0].Collide(new ExcelAddress("B2:B11"))); - Assert.AreEqual(ExcelAddressBase.eAddressCollition.Equal, cf.Address.Addresses[1].Collide(new ExcelAddress("E5:E8"))); + Assert.AreEqual(ExcelAddressBase.eAddressCollision.Equal, cf.Address.Addresses[0].Collide(new ExcelAddress("B2:B11"))); + Assert.AreEqual(ExcelAddressBase.eAddressCollision.Equal, cf.Address.Addresses[1].Collide(new ExcelAddress("E5:E8"))); } [TestMethod] public void ValidateConditionalFormattingInsertRow() @@ -980,8 +980,8 @@ public void ValidateConditionalFormattingInsertRow() ws.Cells["B11:C12"].Insert(eShiftTypeInsert.EntireRow); - Assert.AreEqual(ExcelAddressBase.eAddressCollition.Equal, cf.Address.Addresses[0].Collide(new ExcelAddress("B2:B12"))); - Assert.AreEqual(ExcelAddressBase.eAddressCollition.Equal, cf.Address.Addresses[1].Collide(new ExcelAddress("E5:E8"))); + Assert.AreEqual(ExcelAddressBase.eAddressCollision.Equal, cf.Address.Addresses[0].Collide(new ExcelAddress("B2:B12"))); + Assert.AreEqual(ExcelAddressBase.eAddressCollision.Equal, cf.Address.Addresses[1].Collide(new ExcelAddress("E5:E8"))); } [TestMethod] public void ValidateConditionalFormattingInsertColumn() @@ -992,8 +992,8 @@ public void ValidateConditionalFormattingInsertColumn() ws.Cells["B11:C12"].Insert(eShiftTypeInsert.EntireColumn); - Assert.AreEqual(ExcelAddressBase.eAddressCollition.Equal, cf.Address.Addresses[0].Collide(new ExcelAddress("D2:D10"))); - Assert.AreEqual(ExcelAddressBase.eAddressCollition.Equal, cf.Address.Addresses[1].Collide(new ExcelAddress("G5:G8"))); + Assert.AreEqual(ExcelAddressBase.eAddressCollision.Equal, cf.Address.Addresses[0].Collide(new ExcelAddress("D2:D10"))); + Assert.AreEqual(ExcelAddressBase.eAddressCollision.Equal, cf.Address.Addresses[1].Collide(new ExcelAddress("G5:G8"))); } [TestMethod] public void ValidateConditionalFormattingInsertDownMiddle() @@ -1004,8 +1004,8 @@ public void ValidateConditionalFormattingInsertDownMiddle() ws.Cells["B3"].Insert(eShiftTypeInsert.Down); - Assert.AreEqual(ExcelAddressBase.eAddressCollition.Equal, cf.Address.Addresses[0].Collide(new ExcelAddress("B2:B11"))); - Assert.AreEqual(ExcelAddressBase.eAddressCollition.Equal, cf.Address.Addresses[1].Collide(new ExcelAddress("E5:E8"))); + Assert.AreEqual(ExcelAddressBase.eAddressCollision.Equal, cf.Address.Addresses[0].Collide(new ExcelAddress("B2:B11"))); + Assert.AreEqual(ExcelAddressBase.eAddressCollision.Equal, cf.Address.Addresses[1].Collide(new ExcelAddress("E5:E8"))); } diff --git a/src/EPPlusTest/DataValidation/DataValidationTests.cs b/src/EPPlusTest/DataValidation/DataValidationTests.cs index 882209cdb8..2a327c653e 100644 --- a/src/EPPlusTest/DataValidation/DataValidationTests.cs +++ b/src/EPPlusTest/DataValidation/DataValidationTests.cs @@ -646,7 +646,7 @@ public void ClearValidationAndAddressChangeWithSpacedAddresses() { var ws2 = pck2.Workbook.Worksheets[0]; var address = ws2.DataValidations[0].Address; - Assert.IsTrue(address.Collide(new ExcelAddressBase("A3")) == ExcelAddressBase.eAddressCollition.No); + Assert.IsTrue(address.Collide(new ExcelAddressBase("A3")) == ExcelAddressBase.eAddressCollision.No); } } diff --git a/src/EPPlusTest/FormulaParsing/ExcelUtilities/RangeAddressTests.cs b/src/EPPlusTest/FormulaParsing/ExcelUtilities/RangeAddressTests.cs index 1fe60b9a29..2ce5764c2b 100644 --- a/src/EPPlusTest/FormulaParsing/ExcelUtilities/RangeAddressTests.cs +++ b/src/EPPlusTest/FormulaParsing/ExcelUtilities/RangeAddressTests.cs @@ -61,7 +61,7 @@ public void CollideShouldReturnTrueIfRangesCollides() var address1 = _factory.Create("A1:A6"); var address2 = _factory.Create("A5"); var result = address1.CollidesWith(address2); - Assert.AreEqual(eAddressCollition.Inside, result); + Assert.AreEqual(eAddressCollision.Inside, result); } [TestMethod] @@ -70,7 +70,7 @@ public void CollideShouldReturnFalseIfRangesDoesNotCollide() var address1 = _factory.Create("A1:A6"); var address2 = _factory.Create("A8"); var result = address1.CollidesWith(address2); - Assert.AreEqual(eAddressCollition.No, result); + Assert.AreEqual(eAddressCollision.No, result); } [TestMethod] public void CollideShouldReturnFalseIfRangesCollidesButWorksheetNameDiffers() @@ -78,7 +78,7 @@ public void CollideShouldReturnFalseIfRangesCollidesButWorksheetNameDiffers() var address1 = _factory.Create("Sheet2!A1:A6"); var address2 = _factory.Create("A5"); var result = address1.CollidesWith(address2); - Assert.AreEqual(eAddressCollition.No, result); + Assert.AreEqual(eAddressCollision.No, result); } [TestMethod] public void ValidateTableAddressIsValue() From c064cf125811dc55b2ef638afc52c75e9f49dcd9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ossian=20Edstr=C3=B6m?= Date: Tue, 20 Oct 2026 11:08:24 +0200 Subject: [PATCH 7/7] Added more functional internal unify addresses --- src/EPPlus/Core/RangeCopyHelper.cs | 22 ++++--- src/EPPlus/ExcelAddressBase.cs | 64 +++++++++++++++++++ .../Core/Range/Insert/RangeInsertTests.cs | 9 ++- 3 files changed, 84 insertions(+), 11 deletions(-) diff --git a/src/EPPlus/Core/RangeCopyHelper.cs b/src/EPPlus/Core/RangeCopyHelper.cs index 5943587842..0c8b22c946 100644 --- a/src/EPPlus/Core/RangeCopyHelper.cs +++ b/src/EPPlus/Core/RangeCopyHelper.cs @@ -291,6 +291,7 @@ private void CopyDataValidations() { //Get the range of actual validations within the source range //As the source range can include empty data etc. + //Then move that range to top left of destination newAddress = HandleAddress(dv.Address); } else @@ -319,14 +320,15 @@ private void CopyDataValidations() if (_sourceRange._worksheet == _destinationRange._worksheet) { var unifiedAddress = dv.Address.UnifyAddressesIfPossible(dv.Address, new ExcelAddressBase(newAddress)); - if (unifiedAddress != null) - { - dv.SetAddress(unifiedAddress.Address); - } - else - { - dv.SetAddress(dv.Address + "," + newAddress); - } + //if (unifiedAddress != null) + //{ + // dv.SetAddress(unifiedAddress.Address); + //} + //else + //{ + // dv.SetAddress(dv.Address + "," + newAddress); + //} + dv.SetAddress(dv.Address + "," + newAddress); dv._ws.DataValidations.UpdateRangeDictionary(dv); } else @@ -407,7 +409,9 @@ private string HandleAddress(ExcelAddressBase inAddress) if (inAddress == null) return ""; } } - if (inAddress.Collide(_sourceRange) != eAddressCollision.No) + + var collision = inAddress.Collide(_sourceRange); + if (collision != eAddressCollision.No) { var address = _sourceRange.Intersect(inAddress); var rowOffset = address._fromRow - _sourceRange._fromRow; diff --git a/src/EPPlus/ExcelAddressBase.cs b/src/EPPlus/ExcelAddressBase.cs index 84715bac51..f03b6d7157 100644 --- a/src/EPPlus/ExcelAddressBase.cs +++ b/src/EPPlus/ExcelAddressBase.cs @@ -2190,6 +2190,70 @@ internal ExcelAddressBase CloneWithOffset(int row, int col) return ret; } + internal void UnifyAddresses() + { + if (Addresses != null) + { + var orderedAddresses = Addresses.OrderBy(x => x.Address).ToList(); + var lastAddress = orderedAddresses[0]; + List unifiedAddresses = new List(); + List terminationAddresses = new List(); + + for (int i = 1; i < orderedAddresses.Count; i++) + { + var unitedAddr = UnifyAddressesIfPossible(lastAddress, orderedAddresses[i]); + if (unitedAddr != null) + { + terminationAddresses.Add(orderedAddresses[i]); + if (unifiedAddresses.Count == 0) + { + terminationAddresses.Add(orderedAddresses[0]); + unifiedAddresses.Add(unitedAddr); + } + else if(unifiedAddresses.Last() != lastAddress) + { + unifiedAddresses.Add(unitedAddr); + } + else if(unifiedAddresses.Last() == lastAddress) + { + unifiedAddresses[unifiedAddresses.Count - 1] = unitedAddr; + } + + lastAddress = unitedAddr; + } + else + { + lastAddress = orderedAddresses[i]; + } + } + + foreach(var adr in terminationAddresses) + { + Addresses.Remove(adr); + } + foreach(var adr in unifiedAddresses) + { + Addresses.Add(adr); + } + + if(Addresses.Count == 1 && unifiedAddresses.Count == 1) + { + _address = unifiedAddresses[0].Address; + Addresses.Clear(); + } + else + { + string fullAddress = string.Empty; + foreach(var adr in Addresses) + { + if (fullAddress != string.Empty) fullAddress += ","; + fullAddress = adr.Address; + } + _address = fullAddress; + } + } + } + //Merge/Unify two addresses //e.g. if an address is 'A2:A4, A5' it could also be written as one unified range 'A2:A5' instead of comma separated //NOTE: Has NOTHING to do with MergedCells or the like. diff --git a/src/EPPlusTest/Core/Range/Insert/RangeInsertTests.cs b/src/EPPlusTest/Core/Range/Insert/RangeInsertTests.cs index 6d455cf3ee..ae851d4e35 100644 --- a/src/EPPlusTest/Core/Range/Insert/RangeInsertTests.cs +++ b/src/EPPlusTest/Core/Range/Insert/RangeInsertTests.cs @@ -1753,12 +1753,17 @@ public void InsertRow_UnderLastTableDataRow_VerifyQuadRangeUpdates() //Verify data validation does exist at new address Assert.AreEqual(1, validationsAtNewAddress.Count); - //Copy the moved validation and apply it to the new rows - wks.Cells["A5"].Copy(wks.Cells["A2:A4"], ExcelRangeCopyOnly.Validations); + for(int i = 0; i < 3; i++) + { + //Copy the moved validation and apply it to the new rows + wks.Cells["A5"].Copy(wks.Cells[2 + i, 1], ExcelRangeCopyOnly.Validations); + } // THEN there is still a single data validation, and it covers every data row in the table Assert.AreEqual(1, wks.DataValidations.Count); //Verify copying Also unified the addresses instead of comma separating if possible + Assert.AreEqual("A5,A2,A3,A4", wks.DataValidations[0].Address.Address); + wks.DataValidations[0].Address.UnifyAddresses(); Assert.AreEqual("A2:A5", wks.DataValidations[0].Address.Address); } }