sc/inc/SheetView.hxx | 18 ++++ sc/inc/SheetViewManager.hxx | 2 sc/qa/unit/tiledrendering/SheetViewTest.cxx | 44 +++++++++-- sc/source/core/data/SheetView.cxx | 75 +++++++++++++++++--- sc/source/core/data/SheetViewManager.cxx | 8 ++ sc/source/core/data/table3.cxx | 2 sc/source/ui/docshell/SheetViewOperationsTester.cxx | 36 +++++---- sc/source/ui/operation/Operation.cxx | 63 +++++++++++----- sc/source/ui/operation/SetNormalStringOperation.cxx | 48 ++++++------ sc/source/ui/view/viewfunc.cxx | 45 ------------ 10 files changed, 220 insertions(+), 121 deletions(-)
New commits: commit 46c048e17d11e308b7c4fc9dc45e8d840a1ba55a Author: Tomaž Vajngerl <[email protected]> AuthorDate: Tue Feb 10 12:57:50 2026 +0900 Commit: Miklos Vajna <[email protected]> CommitDate: Mon Feb 16 09:32:09 2026 +0100 sc: Syncing for SetNormalString operation This reverts sorting in EnterData as we can do the sync in the lower level with the current approach of overwriting. We need to store the sc:ReorderParam and merge its order on change, which can be used to reverse the sorting done to the default view to the point when the sheet view was created. Then we can reapply the sorting to the sheet view to restore it to the last state. As SortOrderReverser and ReorderParam are partially storing the same data, we might consider to combine them in the future. Change-Id: Ia1e4757296ca87de3f91ca1b5223f993b55246c5 Reviewed-on: https://gerrit.libreoffice.org/c/core/+/199180 Reviewed-by: Miklos Vajna <[email protected]> Tested-by: Jenkins CollaboraOffice <[email protected]> diff --git a/sc/inc/SheetView.hxx b/sc/inc/SheetView.hxx index 9d5daa3180b7..6fde48e9b171 100644 --- a/sc/inc/SheetView.hxx +++ b/sc/inc/SheetView.hxx @@ -68,6 +68,9 @@ private: std::optional<SortOrderReverser> moSortOrder; SheetViewID mnID; + std::optional<ReorderParam> moOriginalReorderParams; + std::optional<ScSortParam> moSortParam; + public: SheetView(ScTable* pTable, OUString const& rName, SheetViewID nID); @@ -87,6 +90,7 @@ public: bool isSynced() const { return mbSynced; } std::optional<SortOrderReverser> const& getSortOrder() const { return moSortOrder; } + void resetSortOrder() { moSortOrder.reset(); } /** Adds or combines the order indices. * @@ -94,6 +98,20 @@ public: * were already added previously. **/ void addOrderIndices(SortOrderInfo const& rSortInfo); + + /** Merges the reorder parameters */ + void mergeReorderParameters(ReorderParam const& rReorderParameters); + std::optional<ReorderParam> const& getReorderParameters() { return moOriginalReorderParams; } + + /** Reverses the complete (sheet view and default view) sorting order for the input row */ + SCROW reverseSortingToDefaultView(SCROW nRow, SCCOL nColumn) const; + + // Last used sort parameters + + std::optional<ScSortParam> const& getSortPram() { return moSortParam; } + + /// Remember last used sort parameters when sheet view was sorted. + void setSortParam(ScSortParam const& rSortParam) { moSortParam = rSortParam; } }; } diff --git a/sc/inc/SheetViewManager.hxx b/sc/inc/SheetViewManager.hxx index 9180f4a891db..30afd0bc86c8 100644 --- a/sc/inc/SheetViewManager.hxx +++ b/sc/inc/SheetViewManager.hxx @@ -70,6 +70,8 @@ public: std::optional<SortOrderReverser> const& getSortOrder() const { return moSortOrder; } void addOrderIndices(SortOrderInfo const& rSortInfo); + + void mergeReorderParameters(ReorderParam const& rReorderParameters); }; } diff --git a/sc/qa/unit/tiledrendering/SheetViewTest.cxx b/sc/qa/unit/tiledrendering/SheetViewTest.cxx index 50a7c906cb5a..b2db66c40b8c 100644 --- a/sc/qa/unit/tiledrendering/SheetViewTest.cxx +++ b/sc/qa/unit/tiledrendering/SheetViewTest.cxx @@ -898,6 +898,12 @@ CPPUNIT_TEST_FIXTURE(SheetViewTest, testSyncAfterSorting_SheetViewSort) // New Sheet view dispatchCommand(mxComponent, u".uno:NewSheetView"_ustr, {}); + // Expect the data is same in both + CPPUNIT_ASSERT_EQUAL(expectedValues({ u"4", u"5", u"3", u"7" }), + getValues(pTabViewSheetView, 0, 1, 4)); + CPPUNIT_ASSERT_EQUAL(expectedValues({ u"4", u"5", u"3", u"7" }), + getValues(pTabViewDefaultView, 0, 1, 4)); + // Sort AutoFilter dispatchCommand(mxComponent, u".uno:SortAscending"_ustr, {}); @@ -909,7 +915,10 @@ CPPUNIT_TEST_FIXTURE(SheetViewTest, testSyncAfterSorting_SheetViewSort) typeCharsInCell(std::string("9"), 0, 1, pTabViewSheetView, pModelObj); - CPPUNIT_ASSERT_EQUAL(expectedValues({ u"9", u"4", u"5", u"7" }), + // Sheet view is automatically sorted if it was sorted before. + // So it would be { u"9", u"4", u"5", u"7" } + // and then sorted to { u"4", u"5", u"7", u"9" } + CPPUNIT_ASSERT_EQUAL(expectedValues({ u"4", u"5", u"7", u"9" }), getValues(pTabViewSheetView, 0, 1, 4)); CPPUNIT_ASSERT_EQUAL(expectedValues({ u"4", u"5", u"9", u"7" }), getValues(pTabViewDefaultView, 0, 1, 4)); @@ -926,10 +935,11 @@ CPPUNIT_TEST_FIXTURE(SheetViewTest, testSyncAfterSorting_SheetViewSort) typeCharsInCell(std::string("6"), 0, 3, pTabViewSheetView, pModelObj); - CPPUNIT_ASSERT_EQUAL(expectedValues({ u"9", u"7", u"6", u"4" }), - getValues(pTabViewSheetView, 0, 1, 4)); CPPUNIT_ASSERT_EQUAL(expectedValues({ u"4", u"6", u"9", u"7" }), getValues(pTabViewDefaultView, 0, 1, 4)); + + CPPUNIT_ASSERT_EQUAL(expectedValues({ u"9", u"7", u"6", u"4" }), + getValues(pTabViewSheetView, 0, 1, 4)); } } @@ -959,11 +969,23 @@ CPPUNIT_TEST_FIXTURE(SheetViewTest, testSyncAfterSorting_SortInDefaultAndSheetVi dispatchCommand(mxComponent, u".uno:NewSheetView"_ustr, {}); + CPPUNIT_ASSERT_EQUAL(expectedValues({ u"4", u"5", u"3", u"7" }), + getValues(pTabViewDefaultView, 0, 1, 4)); + + CPPUNIT_ASSERT_EQUAL(expectedValues({ u"4", u"5", u"3", u"7" }), + getValues(pTabViewSheetView, 0, 1, 4)); + // Sort AutoFilter dispatchCommand(mxComponent, u".uno:SortAscending"_ustr, {}); + + CPPUNIT_ASSERT_EQUAL(expectedValues({ u"4", u"5", u"3", u"7" }), + getValues(pTabViewDefaultView, 0, 1, 4)); + + CPPUNIT_ASSERT_EQUAL(expectedValues({ u"3", u"4", u"5", u"7" }), + getValues(pTabViewSheetView, 0, 1, 4)); } - // Switch to Sheet View and Create + // Switch to Default view and sort { SfxLokHelper::setView(aDefaultView.getViewID()); Scheduler::ProcessEventsToIdle(); @@ -971,24 +993,28 @@ CPPUNIT_TEST_FIXTURE(SheetViewTest, testSyncAfterSorting_SortInDefaultAndSheetVi // Sort AutoFilter dispatchCommand(mxComponent, u".uno:SortDescending"_ustr, {}); - // Check values + CPPUNIT_ASSERT_EQUAL(expectedValues({ u"7", u"5", u"4", u"3" }), + getValues(pTabViewDefaultView, 0, 1, 4)); CPPUNIT_ASSERT_EQUAL(expectedValues({ u"3", u"4", u"5", u"7" }), getValues(pTabViewSheetView, 0, 1, 4)); - CPPUNIT_ASSERT_EQUAL(expectedValues({ u"7", u"5", u"4", u"3" }), - getValues(pTabViewDefaultView, 0, 1, 4)); } + // Switch to Sheet view and set a value { SfxLokHelper::setView(aSheetView.getViewID()); Scheduler::ProcessEventsToIdle(); + // Change "4" to "44" typeCharsInCell(std::string("44"), 0, 2, pTabViewSheetView, pModelObj); - CPPUNIT_ASSERT_EQUAL(expectedValues({ u"3", u"44", u"5", u"7" }), - getValues(pTabViewSheetView, 0, 1, 4)); CPPUNIT_ASSERT_EQUAL(expectedValues({ u"7", u"5", u"44", u"3" }), getValues(pTabViewDefaultView, 0, 1, 4)); + + // Result in { u"3", u"44", u"5", u"7" } but we resort the sheet view immediately + // so we get { u"3", u"5", u"7", u"44" }. + CPPUNIT_ASSERT_EQUAL(expectedValues({ u"3", u"5", u"7", u"44" }), + getValues(pTabViewSheetView, 0, 1, 4)); } } diff --git a/sc/source/core/data/SheetView.cxx b/sc/source/core/data/SheetView.cxx index 70a5177d7401..bb2d78303fd6 100644 --- a/sc/source/core/data/SheetView.cxx +++ b/sc/source/core/data/SheetView.cxx @@ -12,6 +12,25 @@ namespace sc { +namespace +{ +/** Merge sort order arrays, so the order is the same as it would be by doing multiple independent sort operation */ +std::vector<SCCOLROW> mergeOrder(std::vector<SCCOLROW> const& rExistingOrder, + std::vector<SCCOLROW> const& rAddedOrder) +{ + size_t nOrderSize = rExistingOrder.size(); + assert(nOrderSize == rAddedOrder.size()); + + std::vector<SCCOLROW> aNewOrder(nOrderSize); + for (size_t nIndex = 0; nIndex < nOrderSize; ++nIndex) + { + size_t nSortedIndex = rAddedOrder[nIndex] - 1; + aNewOrder[nIndex] = rExistingOrder[nSortedIndex]; + } + return aNewOrder; +} +} + void SortOrderReverser::addOrderIndices(SortOrderInfo const& rSortInfo) { bool bKeyStatesEqual = std::equal(rSortInfo.maKeyStates.begin(), rSortInfo.maKeyStates.begin(), @@ -27,17 +46,7 @@ void SortOrderReverser::addOrderIndices(SortOrderInfo const& rSortInfo) } else { - // merge the order - size_t nOrderSize = maSortInfo.maOrder.size(); - assert(nOrderSize == rSortInfo.maOrder.size()); - - std::vector<SCCOLROW> aNewOrder(nOrderSize); - for (size_t nIndex = 0; nIndex < nOrderSize; ++nIndex) - { - size_t nSortedIndex = rSortInfo.maOrder[nIndex]; - aNewOrder[nIndex] = maSortInfo.maOrder[nSortedIndex - 1]; - } - maSortInfo.maOrder = aNewOrder; + maSortInfo.maOrder = mergeOrder(maSortInfo.maOrder, rSortInfo.maOrder); } } else @@ -103,6 +112,50 @@ void SheetView::addOrderIndices(SortOrderInfo const& rSortInfo) moSortOrder.emplace(); moSortOrder->addOrderIndices(rSortInfo); } + +void SheetView::mergeReorderParameters(ReorderParam const& rReorderParameters) +{ + if (moOriginalReorderParams) + { + moOriginalReorderParams->maOrderIndices = mergeOrder( + moOriginalReorderParams->maOrderIndices, rReorderParameters.maOrderIndices); + } + else + { + moOriginalReorderParams = rReorderParameters; + } } +SCROW SheetView::reverseSortingToDefaultView(SCROW nRow, SCCOL nColumn) const +{ + SCROW nUnsortedRow = nRow; + + // Unsort the sheet view's sort and bring it to the default view's order + // when the sheet view was created. + if (moSortOrder) + { + nUnsortedRow = moSortOrder->unsort(nRow, nColumn); + } + + // Resort the default view's sort done since the sheet view creation. + SCROW nResortedRow = nUnsortedRow; + if (moOriginalReorderParams) + { + ScRange const& rRange = moOriginalReorderParams->maSortRange; + + SortOrderReverser aReverser; + aReverser.addOrderIndices({ rRange.aStart.Col(), + rRange.aEnd.Col(), + rRange.aStart.Row(), + rRange.aEnd.Row(), + moOriginalReorderParams->maOrderIndices, + {} }); + + nResortedRow = aReverser.resort(nUnsortedRow, nColumn); + } + return nResortedRow; +} + +} // end sc namespace + /* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sc/source/core/data/SheetViewManager.cxx b/sc/source/core/data/SheetViewManager.cxx index e91c6e6fa0c7..b4f3c6da4fd2 100644 --- a/sc/source/core/data/SheetViewManager.cxx +++ b/sc/source/core/data/SheetViewManager.cxx @@ -141,6 +141,14 @@ void SheetViewManager::addOrderIndices(SortOrderInfo const& rSortInfo) moSortOrder.emplace(); moSortOrder->addOrderIndices(rSortInfo); } + +void SheetViewManager::mergeReorderParameters(ReorderParam const& rReorderParameters) +{ + for (auto& pSheetView : maViews) + { + pSheetView->mergeReorderParameters(rReorderParameters); + } +} } /* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/sc/source/core/data/table3.cxx b/sc/source/core/data/table3.cxx index 07839f24d148..e9f38daf88d0 100644 --- a/sc/source/core/data/table3.cxx +++ b/sc/source/core/data/table3.cxx @@ -1775,10 +1775,12 @@ void ScTable::Sort( { auto pSheetView = GetDefaultViewTable()->GetSheetViewManager()->get(mnSheetViewID); pSheetView->addOrderIndices(aSortOrderInfo); + pSheetView->setSortParam(aSortParam); } else if (GetSheetViewManager()) { GetSheetViewManager()->addOrderIndices(aSortOrderInfo); + GetSheetViewManager()->mergeReorderParameters(*pUndo); } } } diff --git a/sc/source/ui/docshell/SheetViewOperationsTester.cxx b/sc/source/ui/docshell/SheetViewOperationsTester.cxx index 216507a8f407..6ca6f9a62e1c 100644 --- a/sc/source/ui/docshell/SheetViewOperationsTester.cxx +++ b/sc/source/ui/docshell/SheetViewOperationsTester.cxx @@ -14,6 +14,7 @@ #include <sal/log.hxx> #include <dbdata.hxx> #include <queryparam.hxx> +#include <sortparam.hxx> namespace sc { @@ -139,12 +140,7 @@ constexpr bool doesUnsyncSheetView(OperationType eOperationType) } // end anonymous namespace -bool SheetViewOperationsTester::doesUnsync(OperationType eOperationType) -{ - bool bOperationAllowed = eOperationType == OperationType::EnterData - || eOperationType == OperationType::SetNormalString; - return !bOperationAllowed; -} +bool SheetViewOperationsTester::doesUnsync(OperationType /*eOperationType*/) { return true; } void SheetViewOperationsTester::sync() { @@ -166,12 +162,11 @@ void SheetViewOperationsTester::sync() if (pManager->isEmpty()) return; - for (auto const& pSheetView : pManager->getSheetViews()) + for (std::shared_ptr<SheetView> const& pSheetView : pManager->getSheetViews()) { SCTAB nSheetViewTab = pSheetView->getTableNumber(); std::optional<ScQueryParam> oQueryParam; - std::optional<ScSortParam> oSortParam; ScDBData* pNoNameData = rDocument.GetAnonymousDBData(nSheetViewTab); if (pNoNameData && pNoNameData->HasAutoFilter()) { @@ -180,19 +175,30 @@ void SheetViewOperationsTester::sync() oQueryParam.emplace(); pNoNameData->GetQueryParam(*oQueryParam); } - if (pNoNameData->HasSortParam()) - { - oSortParam.emplace(); - pNoNameData->GetSortParam(*oSortParam); - } } rDocument.OverwriteContent(nTab, nSheetViewTab); - if (oQueryParam) - rDocument.Query(nSheetViewTab, *oQueryParam, false, false); + // Reverse the sorting of the default view in the sheet view + if (auto const& rReorderParameters = pSheetView->getReorderParameters()) + { + sc::ReorderParam aReorderParameters(*rReorderParameters); + aReorderParameters.maSortRange.aStart.SetTab(nSheetViewTab); + aReorderParameters.maSortRange.aEnd.SetTab(nSheetViewTab); + aReorderParameters.reverse(); + rDocument.Reorder(aReorderParameters); + } + + auto const& oSortParam = pSheetView->getSortPram(); if (oSortParam) + { + // We need to reset the sort order for the sheet view as we will sort again + pSheetView->resetSortOrder(); rDocument.Sort(nSheetViewTab, *oSortParam, false, false, nullptr, nullptr); + } + + if (oQueryParam) + rDocument.Query(nSheetViewTab, *oQueryParam, false, false); } } diff --git a/sc/source/ui/operation/Operation.cxx b/sc/source/ui/operation/Operation.cxx index 471182de8b84..579c194e7393 100644 --- a/sc/source/ui/operation/Operation.cxx +++ b/sc/source/ui/operation/Operation.cxx @@ -46,23 +46,30 @@ ScAddress Operation::convertAddress(ScAddress const& rAddress) if (!pSheetView) return rAddress; + ScAddress aAddress = rAddress; + SCTAB nTab = aAddress.Tab(); + + // Change the tab number if it is the one from sheet view + if (pViewData->CurrentTabForData() == nTab) + nTab = pViewData->GetTabNumber(); + aAddress.SetTab(nTab); + std::optional<SortOrderReverser> const& oSortOrder = pSheetView->getSortOrder(); if (!oSortOrder) - return rAddress; + return aAddress; - SCTAB nTab = rAddress.Tab(); - SCCOL nColumn = rAddress.Col(); - SCROW nRow = rAddress.Row(); + SCCOL nColumn = aAddress.Col(); + SCROW nRow = aAddress.Row(); if (pViewData->GetTabNumber() != nTab) - return rAddress; + return aAddress; - SCROW nUnsortedRow = oSortOrder->unsort(nRow, nColumn); - if (nUnsortedRow != nRow) - { - return ScAddress(nColumn, nUnsortedRow, nTab); - } - return rAddress; + SCROW nReversedRow = pSheetView->reverseSortingToDefaultView(nRow, nColumn); + + if (nReversedRow == nRow) + return aAddress; + + return ScAddress(nColumn, nReversedRow, nTab); } ScMarkData Operation::convertMark(ScMarkData const& rMarkData) @@ -70,6 +77,8 @@ ScMarkData Operation::convertMark(ScMarkData const& rMarkData) ScViewData* pViewData = ScDocShell::GetViewData(); std::shared_ptr<SheetView> pSheetView = getCurrentSheetView(pViewData); + + // We get a valid pSheetView if we currently are in a sheet view, otherwise we don't need to convert if (!pSheetView) return rMarkData; @@ -81,11 +90,26 @@ ScMarkData Operation::convertMark(ScMarkData const& rMarkData) aNewMark.MarkToMulti(); bool bChanged = false; - for (const SCTAB& nTab : aNewMark) + SCTAB nDefaultViewTab = pViewData->GetTabNumber(); + SCTAB nSheetViewTab = pViewData->CurrentTabForData(); + + // Adjust tab to default view in ranges + if (nSheetViewTab == aNewMark.GetArea().aStart.Tab() + && nSheetViewTab == aNewMark.GetArea().aEnd.Tab()) { - if (pViewData->GetTabNumber() != nTab) - continue; + aNewMark.SetAreaTab(nDefaultViewTab); + } + // If sheet view tab is selected, deselect and select default view tab instead + if (aNewMark.GetTableSelect(nSheetViewTab)) + { + aNewMark.SelectTable(nSheetViewTab, false); + aNewMark.SelectTable(nDefaultViewTab, true); + } + + // Take sorting into account when we convert to default view + if (aNewMark.GetTableSelect(nDefaultViewTab)) + { std::vector<std::pair<SCCOL, SCROW>> aMarkedCells; SortOrderInfo const& rSortInfo = oSortOrder->maSortInfo; for (SCROW nRow = rSortInfo.mnFirstRow; nRow <= rSortInfo.mnLastRow; ++nRow) @@ -95,17 +119,18 @@ ScMarkData Operation::convertMark(ScMarkData const& rMarkData) { if (aNewMark.IsCellMarked(nColumn, nRow)) { - aNewMark.SetMultiMarkArea(ScRange(nColumn, nRow, nTab, nColumn, nRow, nTab), - false); + ScRange aRange(nColumn, nRow, nDefaultViewTab, nColumn, nRow, nDefaultViewTab); + aNewMark.SetMultiMarkArea(aRange, false); aMarkedCells.emplace_back(nColumn, nRow); } } } for (auto & [ nColumn, nRow ] : aMarkedCells) { - SCROW nUnsortedRow = oSortOrder->unsort(nRow, nColumn); - aNewMark.SetMultiMarkArea( - ScRange(nColumn, nUnsortedRow, nTab, nColumn, nUnsortedRow, nTab), true); + SCROW nReversedRow = pSheetView->reverseSortingToDefaultView(nRow, nColumn); + ScRange aRange(nColumn, nReversedRow, nDefaultViewTab, nColumn, nReversedRow, + nDefaultViewTab); + aNewMark.SetMultiMarkArea(aRange, true); bChanged = true; } } diff --git a/sc/source/ui/operation/SetNormalStringOperation.cxx b/sc/source/ui/operation/SetNormalStringOperation.cxx index 921bd8de7bb7..2dfdcbf74fef 100644 --- a/sc/source/ui/operation/SetNormalStringOperation.cxx +++ b/sc/source/ui/operation/SetNormalStringOperation.cxx @@ -39,12 +39,12 @@ bool SetNormalStringOperation::runImplementation() bool bUndo(rDoc.IsUndoEnabled()); - if (!checkSheetViewProtection()) - return false; + sc::SheetViewOperationsTester aSheetViewTester(ScDocShell::GetViewData()); + + ScAddress aPosition = convertAddress(mrPosition); ScEditableTester aTester = ScEditableTester::CreateAndTestBlock( - rDoc, mrPosition.Tab(), mrPosition.Col(), mrPosition.Row(), mrPosition.Col(), - mrPosition.Row()); + rDoc, aPosition.Tab(), aPosition.Col(), aPosition.Row(), aPosition.Col(), aPosition.Row()); if (!aTester.IsEditable()) { if (!mbApi) @@ -52,18 +52,18 @@ bool SetNormalStringOperation::runImplementation() return false; } - bool bEditDeleted = (rDoc.GetCellType(mrPosition) == CELLTYPE_EDIT); + bool bEditDeleted = (rDoc.GetCellType(aPosition) == CELLTYPE_EDIT); ScUndoEnterData::ValuesType aOldValues; if (bUndo) { ScUndoEnterData::Value aOldValue; - aOldValue.mnTab = mrPosition.Tab(); - aOldValue.maCell.assign(rDoc, mrPosition); + aOldValue.mnTab = aPosition.Tab(); + aOldValue.maCell.assign(rDoc, aPosition); const ScPatternAttr* pPattern - = rDoc.GetPattern(mrPosition.Col(), mrPosition.Row(), mrPosition.Tab()); + = rDoc.GetPattern(aPosition.Col(), aPosition.Row(), aPosition.Tab()); if (const SfxUInt32Item* pItem = pPattern->GetItemSet().GetItemIfSet(ATTR_VALUE_FORMAT, false)) { @@ -76,36 +76,38 @@ bool SetNormalStringOperation::runImplementation() aOldValues.push_back(aOldValue); } - tools::Long nBefore(mrDocShell.GetTwipWidthHint(mrPosition)); - mbIsNumberFormatSet - = rDoc.SetString(mrPosition.Col(), mrPosition.Row(), mrPosition.Tab(), mrText); - tools::Long nAfter(mrDocShell.GetTwipWidthHint(mrPosition)); + tools::Long nBefore(mrDocShell.GetTwipWidthHint(aPosition)); + mbIsNumberFormatSet = rDoc.SetString(aPosition.Col(), aPosition.Row(), aPosition.Tab(), mrText); + tools::Long nAfter(mrDocShell.GetTwipWidthHint(aPosition)); if (bUndo) { // because of ChangeTracking, UndoAction can be created only after SetString was called - mrDocShell.GetUndoManager()->AddUndoAction(std::make_unique<ScUndoEnterData>( - &mrDocShell, mrPosition, aOldValues, mrText, nullptr)); + mrDocShell.GetUndoManager()->AddUndoAction( + std::make_unique<ScUndoEnterData>(&mrDocShell, aPosition, aOldValues, mrText, nullptr)); } - if (bEditDeleted || rDoc.HasAttrib(ScRange(mrPosition), HasAttrFlags::NeedHeight)) - mrDocFunc.AdjustRowHeight(ScRange(mrPosition), true, mbApi); + if (bEditDeleted || rDoc.HasAttrib(ScRange(aPosition), HasAttrFlags::NeedHeight)) + mrDocFunc.AdjustRowHeight(ScRange(aPosition), true, mbApi); + + if (sc::SheetViewOperationsTester::doesUnsync(meType)) + aSheetViewTester.sync(); - mrDocShell.PostPaintCell(mrPosition, std::max(nBefore, nAfter)); + mrDocShell.PostPaintCell(aPosition, std::max(nBefore, nAfter)); aModificator.SetDocumentModified(); // notify input handler here the same way as in PutCell if (mbApi) - mrDocFunc.NotifyInputHandler(mrPosition); + mrDocFunc.NotifyInputHandler(aPosition); - const SfxUInt32Item* pItem = rDoc.GetAttr(mrPosition, ATTR_VALIDDATA); + const SfxUInt32Item* pItem = rDoc.GetAttr(aPosition, ATTR_VALIDDATA); const ScValidationData* pData = rDoc.GetValidationEntry(pItem->GetValue()); if (pData) { - ScRefCellValue aCell(rDoc, mrPosition); - if (pData->IsDataValid(aCell, mrPosition)) - ScDetectiveFunc(rDoc, mrPosition.Tab()) - .DeleteCirclesAt(mrPosition.Col(), mrPosition.Row()); + ScRefCellValue aCell(rDoc, aPosition); + if (pData->IsDataValid(aCell, aPosition)) + ScDetectiveFunc(rDoc, aPosition.Tab()) + .DeleteCirclesAt(aPosition.Col(), aPosition.Row()); } return true; diff --git a/sc/source/ui/view/viewfunc.cxx b/sc/source/ui/view/viewfunc.cxx index a61de84b1111..a3247278c3d8 100644 --- a/sc/source/ui/view/viewfunc.cxx +++ b/sc/source/ui/view/viewfunc.cxx @@ -834,52 +834,9 @@ void ScViewFunc::EnterData( SCCOL nCol, SCROW nRow, SCTAB nTab, } else { - sc::SheetViewID nSheetViewID = GetViewData().GetSheetViewID(); for (const auto& rTab : aMark) { - if (rDoc.IsSheetViewHolder(rTab)) - continue; - - auto pManager = rDoc.GetSheetViewManager(rTab); - - for (auto const& pSheetView : pManager->getSheetViews()) - { - if (!pSheetView) - continue; - - SCTAB nSheetViewTab = pSheetView->getTableNumber(); - - if (GetViewData().GetSheetViewID() == sc::DefaultSheetViewID) - { - SCROW nUnsortedRow = nRow; - if (pManager->getSortOrder()) - nUnsortedRow = pManager->getSortOrder()->unsort(nUnsortedRow, nCol); - applyText(*this, nCol, nUnsortedRow, nSheetViewTab, rString, bNumFmtChanged); - } - else if (GetViewData().GetSheetViewID() == pSheetView->getID()) - { - applyText(*this, nCol, nRow, nSheetViewTab, rString, bNumFmtChanged); - } - else - { - // TODO - we need to update other sheet views as well, test case needed - } - } - - { - SCROW nUnsortedRow = nRow; - - if (nSheetViewID != sc::DefaultSheetViewID) - { - auto pSheetView = pManager->get(nSheetViewID); - - if (pSheetView->getSortOrder()) - nUnsortedRow = pSheetView->getSortOrder()->unsort(nUnsortedRow, nCol); - if (pManager->getSortOrder()) - nUnsortedRow = pManager->getSortOrder()->resort(nUnsortedRow, nCol); - } - applyText(*this, nCol, nUnsortedRow, rTab, rString, bNumFmtChanged); - } + applyText(*this, nCol, nRow, rTab, rString, bNumFmtChanged); } performAutoFormatAndUpdate(rString, aMark, nCol, nRow, nTab, bNumFmtChanged, bRecord, xModificator, *this);
