36 #include <osl/diagnose.h>
38 #include <com/sun/star/container/XNameContainer.hpp>
39 #include <com/sun/star/script/ModuleType.hpp>
40 #include <com/sun/star/script/XLibraryContainer.hpp>
41 #include <com/sun/star/script/vba/XVBAModuleInfo.hpp>
43 #include <docfunc.hxx>
46 #include <strings.hrc>
60 #include <globstr.hrc>
66 #include <stlpool.hxx>
67 #include <stlsheet.hxx>
70 #include <uiitems.hxx>
79 #include <compiler.hxx>
85 #include <progress.hxx>
89 #include <tokenarray.hxx>
108 #include <config_features.h>
127 rDocShell.GetUndoManager()->AddUndoAction( std::make_unique<ScUndoDraw>( std::move(pUndoAction), &rDocShell ) );
128 rDocShell.SetDrawModified();
133 for (
SCTAB nTab=0; nTab<nTabCount; nTab++)
154 SfxViewShell* pSomeViewForThisDoc = rDocShell.GetBestViewShell(
false);
173 bool bChanged = rDoc.
SetOptimalHeight(aCxt, nStartRow, nEndRow, nTab, bApi);
183 if (pTabViewShell && pTabViewShell->
GetDocId() == pSomeViewForThisDoc->
GetDocId())
186 pPosHelper->invalidateByIndex(nStartRow);
194 if ( bPaint && bChanged )
202 pSomeViewForThisDoc,
false ,
true ,
true ,
203 false ,
false ,
false , nTab);
213 rDocShell.MakeDrawLayer();
222 pModel->BeginCalcUndo(
false);
224 std::unique_ptr<SdrUndoGroup> pUndo;
226 pUndo = pModel->GetCalcUndo();
233 rDocShell.GetUndoManager()->AddUndoAction(
234 std::make_unique<ScUndoDetective>( &rDocShell, std::move(pUndo), &aOperation ) );
237 SfxBindings* pBindings = rDocShell.GetViewBindings();
239 pBindings->
Invalidate( SID_DETECTIVE_REFRESH );
261 pModel->BeginCalcUndo(
false);
263 std::unique_ptr<SdrUndoGroup> pUndo;
265 pUndo = pModel->GetCalcUndo();
272 rDocShell.GetUndoManager()->AddUndoAction(
273 std::make_unique<ScUndoDetective>( &rDocShell, std::move(pUndo), &aOperation ) );
276 SfxBindings* pBindings = rDocShell.GetViewBindings();
278 pBindings->
Invalidate( SID_DETECTIVE_REFRESH );
288 rDocShell.MakeDrawLayer();
298 pModel->BeginCalcUndo(
false);
300 std::unique_ptr<SdrUndoGroup> pUndo;
302 pUndo = pModel->GetCalcUndo();
309 rDocShell.GetUndoManager()->AddUndoAction(
310 std::make_unique<ScUndoDetective>( &rDocShell, std::move(pUndo), &aOperation ) );
313 SfxBindings* pBindings = rDocShell.GetViewBindings();
315 pBindings->
Invalidate( SID_DETECTIVE_REFRESH );
337 pModel->BeginCalcUndo(
false);
339 std::unique_ptr<SdrUndoGroup> pUndo;
341 pUndo = pModel->GetCalcUndo();
348 rDocShell.GetUndoManager()->AddUndoAction(
349 std::make_unique<ScUndoDetective>( &rDocShell, std::move(pUndo), &aOperation ) );
352 SfxBindings* pBindings = rDocShell.GetViewBindings();
354 pBindings->
Invalidate( SID_DETECTIVE_REFRESH );
364 rDocShell.MakeDrawLayer();
374 pModel->BeginCalcUndo(
false);
376 std::unique_ptr<SdrUndoGroup> pUndo;
378 pUndo = pModel->GetCalcUndo();
385 rDocShell.GetUndoManager()->AddUndoAction(
386 std::make_unique<ScUndoDetective>( &rDocShell, std::move(pUndo), &aOperation ) );
389 SfxBindings* pBindings = rDocShell.GetViewBindings();
391 pBindings->
Invalidate( SID_DETECTIVE_REFRESH );
401 rDocShell.MakeDrawLayer();
409 pModel->BeginCalcUndo(
false);
412 std::unique_ptr<SdrUndoGroup> pUndo;
414 pUndo = pModel->GetCalcUndo();
420 pUndo->SetComment(
ScResId( STR_UNDO_DETINVALID ) );
421 rDocShell.GetUndoManager()->AddUndoAction( std::move(pUndo) );
427 VclMessageType::Info, VclButtonsType::Ok,
428 ScResId(STR_DETINVALID_OVERFLOW)));
448 pModel->BeginCalcUndo(
false);
450 std::unique_ptr<SdrUndoGroup> pUndo;
452 pUndo = pModel->GetCalcUndo();
456 std::unique_ptr<ScDetOpList> pUndoList;
457 if (bUndo && pOldList)
464 rDocShell.GetUndoManager()->AddUndoAction(
465 std::make_unique<ScUndoDetective>( &rDocShell, std::move(pUndo),
nullptr, std::move(pUndoList) ) );
468 SfxBindings* pBindings = rDocShell.GetViewBindings();
470 pBindings->
Invalidate( SID_DETECTIVE_REFRESH );
482 if ( pList && pList->
Count() )
484 rDocShell.MakeDrawLayer();
493 for (
SCTAB nTab=0; nTab<nTabCount; nTab++)
499 for (
size_t i=0;
i < nCount; ++
i)
509 aFunc.ShowSucc( nCol, nRow );
512 aFunc.DeleteSucc( nCol, nRow );
515 aFunc.ShowPred( nCol, nRow );
518 aFunc.DeletePred( nCol, nRow );
521 aFunc.ShowError( nCol, nRow );
524 OSL_FAIL(
"wrong operation in DetectiveRefresh");
530 std::unique_ptr<SdrUndoGroup> pUndo = pModel->
GetCalcUndo();
533 pUndo->SetComment(
ScResId( STR_UNDO_DETREFRESH ) );
535 rDocShell.GetUndoManager()->AddUndoAction(
536 std::make_unique<ScUndoDraw>( std::move(pUndo), &rDocShell ),
540 rDocShell.SetDrawModified();
551 vector<ScTokenRef> aRefTokens;
552 if (rSrcRanges.
empty())
556 for (
size_t i = 0,
n = rSrcRanges.
size();
i <
n; ++
i)
561 aDetFunc.GetAllPreds(
566 aDetFunc.GetAllSuccs(
570 rRefTokens.
swap(aRefTokens);
590 OSL_FAIL(
"ScDocFunc::DeleteContents without markings");
614 ScRange aExtendedRange(aMarkRange);
621 sal_uInt16 nExtFlags = 0;
623 rDocShell.UpdatePaintExt( nExtFlags, aMarkRange );
632 if (bRecord && bDrawUndo)
646 std::shared_ptr<ScSimpleUndo::DataSpansType> pDataSpans;
660 rDocShell.GetUndoManager(), &rDocShell, aMultiMark, aExtendedRange,
661 std::move(pUndoDoc), nFlags, pDataSpans, bMulti, bDrawUndo);
664 if (!AdjustRowHeight( aExtendedRange,
true, bApi ))
685 if (!aTester.IsEditable())
687 rDocShell.ErrorMessage(aTester.GetMessageId());
694 sal_uInt16 nExtFlags = 0;
696 rDocShell.UpdatePaintExt(nExtFlags, rPos);
706 if (bDrawUndo && bRecord)
713 std::shared_ptr<ScSimpleUndo::DataSpansType> pDataSpans;
727 rDocShell.GetUndoManager(), &rDocShell, rMark, rPos, std::move(pUndoDoc),
728 nFlags, pDataSpans,
false, bDrawUndo);
731 if (!AdjustRowHeight(rPos,
true, bApi))
770 pUndoDoc->InitUndo( rDoc, nStartTab, nStartTab );
771 for (
const auto& rTab : rMark)
773 if (rTab >= nTabCount)
776 if (rTab != nStartTab)
777 pUndoDoc->AddUndoTab( rTab, rTab );
780 ScRange aCopyRange = aMarkRange;
785 rDocShell.GetUndoManager()->AddUndoAction(
786 std::make_unique<ScUndoTransliterate>( &rDocShell, aMultiMark, std::move(pUndoDoc), nType ) );
791 if (!AdjustRowHeight( aMarkRange,
true,
true ))
806 if (!aTester.IsEditable())
809 rDocShell.ErrorMessage(aTester.GetMessageId());
828 aOldValue.
mnFormat = pItem->GetValue();
833 aOldValues.push_back(aOldValue);
841 rDocShell.GetUndoManager()->AddUndoAction(
842 std::make_unique<ScUndoEnterData>(&rDocShell, rPos, aOldValues, rText,
nullptr));
846 AdjustRowHeight(
ScRange(rPos),
true, bApi );
848 rDocShell.PostPaintCell( rPos );
853 NotifyInputHandler( rPos );
877 aOldVal.
assign(rDoc, rPos);
885 aNewVal.
assign(rDoc, rPos);
886 pUndoMgr->
AddUndoAction(std::make_unique<ScUndoSetCell>(&rDocShell, rPos, aOldVal, aNewVal));
890 AdjustRowHeight(rPos,
true, !bInteraction);
892 rDocShell.PostPaintCell( rPos );
897 NotifyInputHandler( rPos );
907 SCROW nLastRow = rPos.
Row() + aVals.size() - 1;
908 if (nLastRow > rDoc.
MaxRow())
919 std::unique_ptr<sc::UndoSetCells> pUndoObj(
new sc::UndoSetCells(&rDocShell, rPos));
921 pUndoObj->SetNewValues(aVals);
933 NotifyInputHandler(rPos);
946 aOldVal.
assign(rDoc, rPos);
956 aNewVal.
assign(rDoc, rPos);
957 pUndoMgr->
AddUndoAction(std::make_unique<ScUndoSetCell>(&rDocShell, rPos, aOldVal, aNewVal));
961 AdjustRowHeight(rPos,
true, !bInteraction);
963 rDocShell.PostPaintCell( rPos );
968 NotifyInputHandler( rPos );
983 aOldVal.
assign(rDoc, rPos);
991 aNewVal.
assign(rDoc, rPos);
992 pUndoMgr->
AddUndoAction(std::make_unique<ScUndoSetCell>(&rDocShell, rPos, aOldVal, aNewVal));
996 AdjustRowHeight(rPos,
true, !bInteraction);
998 rDocShell.PostPaintCell( rPos );
1003 NotifyInputHandler( rPos );
1017 return SetEditCell(rPos, *pEditText, bInteraction);
1020 return SetStringCell(rPos, rStr, bInteraction);
1025 std::unique_ptr<ScFormulaCell> xCell(pCell);
1035 aOldVal.
assign(rDoc, rPos);
1055 aNewVal.
assign(rDoc, rPos);
1056 pUndoMgr->
AddUndoAction(std::make_unique<ScUndoSetCell>(&rDocShell, rPos, aOldVal, aNewVal));
1060 AdjustRowHeight(rPos,
true, !bInteraction);
1062 rDocShell.PostPaintCell( rPos );
1067 NotifyInputHandler( rPos );
1076 const size_t nLength = rCells.size();
1087 std::unique_ptr<sc::UndoSetCells> pUndoObj;
1102 for (
auto* pCell : rCells)
1106 pCell->SetDirtyVar();
1113 pUndoObj->SetNewValues(rCells);
1123 NotifyInputHandler( rPos );
1149 struct ScMyRememberItem
1154 ScMyRememberItem(
const SfxItemSet& rItemSet, sal_Int32 nTempIndex) :
1155 nIndex(nTempIndex), aItemSet(rItemSet) {}
1177 std::vector<std::unique_ptr<ScMyRememberItem>> aRememberItems;
1184 for (sal_Int32
i=0;
i<nCount;
i++)
1189 if ( !bLoseContent )
1191 aRememberItems.push_back(std::make_unique<ScMyRememberItem>(rEngine.
GetParaAttribs(
i),
i));
1199 bRet = SetEditCell(rPos, *pNewData, !bApi);
1202 for (
const auto& rxItem : aRememberItems)
1208 if ( bUpdateMode && !bLoseContent )
1213 OUString aText = rEngine.
GetText();
1214 if (aText.isEmpty())
1216 bool bNumFmtSet =
false;
1217 bRet = SetNormalString( bNumFmtSet, rPos, aText, bApi );
1220 bRet = SetStringCell(rPos, aText, !bApi);
1231 if ( aPattern.GetItemSet().Count() > 0 )
1235 aMark.SetMarkArea(
ScRange( rPos ) );
1236 ApplyAttributes( aMark, aPattern, bApi );
1241 const ScAddress& rPos,
const OUString& rText,
bool bInterpret,
bool bEnglish,
bool bApi,
1251 ::std::unique_ptr<ScExternalRefManager::ApiGuard> pExtRefGuard;
1264 bSet = SetValueCell(rPos, aRes.
mfValue, !bApi);
1267 bSet = SetStringOrEditCell(rPos, aRes.
maText, !bApi);
1275 else if (!rText.isEmpty())
1277 bSet = SetStringOrEditCell(rPos, rText, !bApi);
1282 bool bNumFmtSet =
false;
1283 bSet = SetNormalString( bNumFmtSet, rPos, rText, bApi );
1299 rDocShell.GetUndoManager()->AddUndoAction( std::make_unique<ScUndoShowHideNote>( rDocShell, rPos, bShow ) );
1307 if (
ScDrawView* pDrawView = pViewData->GetScDrawView())
1308 pDrawView->SyncForGrid( pNote->
GetCaption());
1311 rDocShell.SetDocumentModified();
1322 if (!aTester.IsEditable())
1325 rDocShell.ErrorMessage(aTester.GetMessageId());
1332 pNote->SetText( rPos, aNewText );
1338 rDocShell.PostPaintCell( rPos );
1347 if (aTester.IsEditable())
1353 std::unique_ptr<ScPostIt> pOldNote = rDoc.
ReleaseNote( rPos );
1354 sal_uInt32 nNoteId = 0;
1357 nNoteId = pOldNote->GetId();
1359 pOldNote->GetOrCreateCaption( rPos );
1361 aOldData = pOldNote->GetNoteData();
1369 bool hadOldNote(pOldNote);
1377 if( pAuthor ) pNewNote->
SetAuthor( *pAuthor );
1378 if( pDate ) pNewNote->
SetDate( *pDate );
1386 pUndoMgr->
AddUndoAction( std::make_unique<ScUndoReplaceNote>( rDocShell, rPos, aOldData, aNewData, pDrawLayer->
GetCalcUndo() ) );
1389 rDocShell.PostPaintCell( rPos );
1399 &rDoc, rPos, pNewNote);
1404 rDocShell.ErrorMessage(aTester.GetMessageId());
1413 std::unique_ptr<ScPostIt> pOldNote = rDoc.
ReleaseNote( rPos );
1414 SAL_WARN_IF(pOldNote,
"sc.ui",
"imported data has >1 notes on same cell? at pos " << rPos);
1430 bool bRecord =
true;
1437 bool bOnlyNotBecauseOfMatrix;
1439 && !bOnlyNotBecauseOfMatrix )
1442 rDocShell.ErrorMessage(STR_PROTECTIONERR);
1460 pUndoDoc->InitUndo( rDoc, aMultiRange.
aStart.
Tab(), aMultiRange.
aEnd.
Tab() );
1463 rDocShell.GetUndoManager()->AddUndoAction(
1464 std::make_unique<ScUndoSelectionAttr>(
1468 std::move(pUndoDoc), bMulti, &rPattern ) );
1472 sal_uInt16 nExtFlags = 0;
1473 if ( !bImportingXML )
1474 rDocShell.UpdatePaintExt( nExtFlags, aMultiRange );
1476 bool bChanged =
false;
1481 if ( !bImportingXML )
1482 rDocShell.UpdatePaintExt( nExtFlags, aMultiRange );
1484 if (!AdjustRowHeight( aMultiRange,
true, bApi ))
1499 bool bRecord =
true;
1506 bool bOnlyNotBecauseOfMatrix;
1508 && !bOnlyNotBecauseOfMatrix )
1511 rDocShell.ErrorMessage(STR_PROTECTIONERR);
1516 rStyleName, SfxStyleFamily::Para ));
1534 pUndoDoc->InitUndo( rDoc, nStartTab, nStartTab );
1535 for (
const auto& rTab : rMark)
1537 if (rTab >= nTabCount)
1540 if (rTab != nStartTab)
1541 pUndoDoc->AddUndoTab( rTab, rTab );
1544 ScRange aCopyRange = aMultiRange;
1549 rDocShell.GetUndoManager()->AddUndoAction(
1550 std::make_unique<ScUndoSelectionStyle>(
1551 &rDocShell, rMark, aMultiRange, rStyleName, std::move(pUndoDoc) ) );
1557 if (!AdjustRowHeight( aMultiRange,
true, bApi ))
1587 aRange.aStart.SetCol(0);
1588 aRange.aEnd.SetCol(rDoc.
MaxCol());
1593 auto bIntersects = std::any_of(rMarkData.
begin(), rMarkData.
end(), [&pDPs, &aRange](
const SCTAB& rTab) {
1600 if (aRange.aStart.Row() < 0)
1604 if (aRange.aStart.Row() == 0)
1609 aTest.aStart.IncRow(-1);
1610 aTest.aEnd.SetRow(aTest.aStart.Row());
1611 for (
const auto& rTab : rMarkData)
1613 aTest.aStart.SetTab(rTab);
1614 aTest.aEnd.SetTab(rTab);
1622 aRange.aStart.SetRow(0);
1623 aRange.aEnd.SetRow(rDoc.
MaxRow());
1628 auto bIntersects = std::any_of(rMarkData.begin(), rMarkData.end(), [&pDPs, &aRange](
const SCTAB& rTab) {
1629 return pDPs->
IntersectsTableByRows(aRange.aStart.Col(), aRange.aStart.Row(), aRange.aEnd.Row(), rTab); });
1635 if (aRange.aStart.Col() < 0)
1639 if (aRange.aStart.Col() == 0)
1644 aTest.aStart.IncCol(-1);
1645 aTest.aEnd.SetCol(aTest.aStart.Col());
1646 for (
const auto& rTab : rMarkData)
1648 aTest.aStart.SetTab(rTab);
1649 aTest.aEnd.SetTab(rTab);
1682 aRange.aStart.SetCol(0);
1683 aRange.aEnd.SetCol(rDoc.
MaxCol());
1688 auto bIntersects = std::any_of(rMarkData.
begin(), rMarkData.
end(), [&pDPs, &aRange](
const SCTAB& rTab) {
1695 for (
const auto& rTab : rMarkData)
1697 aTest.aStart.SetTab(rTab);
1698 aTest.aEnd.SetTab(rTab);
1706 aRange.aStart.SetRow(0);
1707 aRange.aEnd.SetRow(rDoc.
MaxRow());
1712 auto bIntersects = std::any_of(rMarkData.begin(), rMarkData.end(), [&pDPs, &aRange](
const SCTAB& rTab) {
1713 return pDPs->
IntersectsTableByRows(aRange.aStart.Col(), aRange.aStart.Row(), aRange.aEnd.Row(), rTab); });
1719 for (
const auto& rTab : rMarkData)
1721 aTest.aStart.SetTab(rTab);
1722 aTest.aEnd.SetTab(rTab);
1737 bool bRecord,
bool bApi,
bool bPartOfPaste )
1742 if (rDocShell.GetDocument().GetChangeTrack() &&
1748 SAL_WARN(
"sc.ui",
"ScDocFunc::InsertCells - no change-tracking of partial cell shift");
1752 ScRange aTargetRange( rRange );
1782 OSL_FAIL(
"invalid row in InsertCells");
1787 SCCOL nPaintStartCol = nStartCol;
1788 SCROW nPaintStartRow = nStartRow;
1789 SCCOL nPaintEndCol = nEndCol;
1790 SCROW nPaintEndRow = nEndRow;
1795 SCCOL nCursorCol = 0;
1796 SCROW nCursorRow = 0;
1817 if( nCount == nEndTab+1 )
1819 aMark.SelectTable(
i,
true );
1827 for (
const auto& rTab : aMark)
1829 if (rTab >= nTabCount)
1836 SCTAB nSelCount = aMark.GetSelectCount();
1840 SCCOL nMergeTestStartCol = nStartCol;
1841 SCROW nMergeTestStartRow = nStartRow;
1842 SCCOL nMergeTestEndCol = nEndCol;
1843 SCROW nMergeTestEndRow = nEndRow;
1845 ScRange aExtendMergeRange( aTargetRange );
1851 nMergeTestEndCol = aExtendMergeRange.
aEnd.
Col();
1852 nMergeTestEndRow = aExtendMergeRange.
aEnd.
Row();
1853 nPaintEndCol = nMergeTestEndCol;
1854 nPaintEndRow = nMergeTestEndRow;
1859 nMergeTestStartCol = 0;
1860 nMergeTestEndCol = rDoc.
MaxCol();
1864 nMergeTestStartRow = 0;
1865 nMergeTestEndRow = rDoc.
MaxRow();
1868 nMergeTestEndRow = rDoc.
MaxRow();
1870 nMergeTestEndCol = rDoc.
MaxCol();
1872 bool bNeedRefresh =
false;
1899 rDoc, nMergeTestStartCol, nMergeTestStartRow, nEditTestEndCol, nEditTestEndRow, aMark);
1910 if (!canInsertCellsByPivot(aTargetRange, aMark, eCmd, rDoc))
1913 rDocShell.ErrorMessage(STR_NO_INSERT_DELETE_OVER_PIVOT_TABLE);
1920 std::unique_ptr<ScRefUndoData> pUndoData;
1924 pRefUndoDoc->InitUndo( rDoc, 0, nTabCount-1 );
1935 bool bInsertMerge =
false;
1936 std::vector<ScRange> qIncreaseRange;
1937 OUString aUndo =
ScResId( STR_UNDO_INSERTCELLS );
1943 rDocShell.GetUndoManager()->EnterListAction( aUndo, aUndo, 0, nViewShellId );
1945 std::unique_ptr<ScUndoRemoveMerge> pUndoRemoveMerge;
1947 for (
const SCTAB i : aMark)
1955 bNeedRefresh =
true;
1957 SCCOL nMergeStartCol = nMergeTestStartCol;
1958 SCROW nMergeStartRow = nMergeTestStartRow;
1959 SCCOL nMergeEndCol = nMergeTestEndCol;
1960 SCROW nMergeEndRow = nMergeTestEndRow;
1962 rDoc.
ExtendMerge( nMergeStartCol, nMergeStartRow, nMergeEndCol, nMergeEndRow,
i );
1963 rDoc.
ExtendOverlapped( nMergeStartCol, nMergeStartRow, nMergeEndCol, nMergeEndRow,
i );
1965 if(( eCmd ==
INS_CELLSDOWN && ( nMergeStartCol != nMergeTestStartCol || nMergeEndCol != nMergeTestEndCol )) ||
1966 (eCmd ==
INS_CELLSRIGHT && ( nMergeStartRow != nMergeTestStartRow || nMergeEndRow != nMergeTestEndRow )) )
1969 rDocShell.ErrorMessage(STR_MSSG_INSERTCELLS_0);
1970 rDocShell.GetUndoManager()->LeaveListAction();
1974 SCCOL nTestCol = -1;
1975 SCROW nTestRow1 = -1;
1976 SCROW nTestRow2 = -1;
1978 ScDocAttrIterator aTestIter( rDoc,
i, nMergeTestStartCol, nMergeTestStartRow, nMergeTestEndCol, nMergeTestEndRow );
1979 ScRange aExtendRange( nMergeTestStartCol, nMergeTestStartRow,
i, nMergeTestEndCol, nMergeTestEndRow,
i );
1981 while ( ( pPattern = aTestIter.
GetNext( nTestCol, nTestRow1, nTestRow2 ) ) !=
nullptr )
1988 ScRange aRange( nTestCol, nTestRow1,
i );
1992 if( nTestRow1 < nTestRow2 && nNewFlags ==
ScMF::Hor )
1994 for(
SCROW nTestRow = nTestRow1; nTestRow <= nTestRow2; nTestRow++ )
1996 ScRange aTestRange( nTestCol, nTestRow,
i );
2000 if( !aExtendRange.
Contains( aMergeRange ) )
2002 qIncreaseRange.push_back( aTestRange );
2003 bInsertMerge =
true;
2010 if( !aExtendRange.
Contains( aMergeRange ) )
2012 qIncreaseRange.push_back( aRange );
2014 bInsertMerge =
true;
2023 nStartRow = aExtendMergeRange.
aStart.
Row();
2024 nEndRow = aExtendMergeRange.
aEnd.
Row();
2027 nEndCol = nMergeTestEndCol;
2037 nStartCol = aExtendMergeRange.
aStart.
Col();
2038 nEndCol = aExtendMergeRange.
aEnd.
Col();
2041 nEndRow = nMergeTestEndRow;
2050 if( !qIncreaseRange.empty() )
2052 if (bRecord && !pUndoRemoveMerge)
2055 pUndoDoc->InitUndo( rDoc, *aMark.begin(), *aMark.rbegin());
2056 pUndoRemoveMerge.reset(
new ScUndoRemoveMerge( &rDocShell, rRange, std::move(pUndoDoc) ));
2059 for(
const ScRange& aRange : qIncreaseRange )
2063 UnmergeCells( aRange, bRecord, pUndoRemoveMerge.get() );
2071 rDocShell.ErrorMessage(STR_MSSG_INSERTCELLS_0);
2072 rDocShell.GetUndoManager()->LeaveListAction();
2078 if (bRecord && pUndoRemoveMerge)
2080 rDocShell.GetUndoManager()->AddUndoAction( std::move(pUndoRemoveMerge));
2086 bSuccess = rDoc.
InsertRow( nStartCol, 0, nEndCol,
MAXTAB, nStartRow, static_cast<SCSIZE>(nEndRow-nStartRow+1), pRefUndoDoc.get(), &aFullMark );
2087 nPaintEndRow = rDoc.
MaxRow();
2091 bSuccess = rDoc.
InsertRow( 0, 0, rDoc.
MaxCol(),
MAXTAB, nStartRow,
static_cast<SCSIZE>(nEndRow-nStartRow+1), pRefUndoDoc.get(), &aFullMark );
2093 nPaintEndCol = rDoc.
MaxCol();
2094 nPaintEndRow = rDoc.
MaxRow();
2098 bSuccess = rDoc.
InsertCol( nStartRow, 0, nEndRow,
MAXTAB, nStartCol, static_cast<SCSIZE>(nEndCol-nStartCol+1), pRefUndoDoc.get(), &aFullMark );
2099 nPaintEndCol = rDoc.
MaxCol();
2103 bSuccess = rDoc.
InsertCol( 0, 0, rDoc.
MaxRow(),
MAXTAB, nStartCol,
static_cast<SCSIZE>(nEndCol-nStartCol+1), pRefUndoDoc.get(), &aFullMark );
2105 nPaintEndRow = rDoc.
MaxRow();
2106 nPaintEndCol = rDoc.
MaxCol();
2110 OSL_FAIL(
"Wrong code at inserting");
2121 std::unique_ptr<SCTAB[]> pTabs(
new SCTAB[nSelCount]);
2122 std::unique_ptr<SCTAB[]> pScenarios(
new SCTAB[nSelCount]);
2124 for (
const auto& rTab : aMark)
2126 if (rTab >= nTabCount)
2133 pScenarios[nUndoPos] = nCount;
2134 pTabs[nUndoPos] = rTab;
2140 rDocShell.GetUndoManager()->LeaveListAction();
2143 rDocShell.GetUndoManager()->AddUndoAction( std::make_unique<ScUndoInsertCells>(
2144 &rDocShell,
ScRange( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab ),
2145 nUndoPos, std::move(pTabs), std::move(pScenarios), eCmd, std::move(pRefUndoDoc), std::move(pUndoData), bPartOfPaste ) );
2150 while( !qIncreaseRange.empty() )
2152 ScRange aRange = qIncreaseRange.back();
2160 aRange.
aEnd.
IncRow(static_cast<SCCOL>(nEndRow-nStartRow+1));
2165 aRange.
aEnd.
IncCol(static_cast<SCCOL>(nEndCol-nStartCol+1));
2174 MergeCells(aMergeOption,
false,
true,
true);
2176 qIncreaseRange.pop_back();
2180 rDocShell.GetUndoManager()->LeaveListAction();
2182 for (
const SCTAB i : aMark)
2190 rDoc.
ExtendMerge( nMergeTestStartCol, nMergeTestStartRow, nMergeTestEndCol, nMergeTestEndRow,
i,
true );
2192 rDoc.
RefreshAutoFilter( nMergeTestStartCol, nMergeTestStartRow, nMergeTestEndCol, nMergeTestEndRow,
i );
2197 sal_uInt16 nExtFlags = 0;
2198 rDocShell.UpdatePaintExt( nExtFlags, nPaintStartCol, nPaintStartRow,
i, nPaintEndCol, nPaintEndRow,
i );
2200 SCTAB nScenarioCount = 0;
2206 AdjustRowHeight(
ScRange(0, nStartRow,
i, rDoc.
MaxCol(), nEndRow,
i+nScenarioCount ),
true, bApi) :
2207 AdjustRowHeight(
ScRange(0, nPaintStartRow,
i, rDoc.
MaxCol(), nPaintEndRow,
i+nScenarioCount ),
true, bApi);
2212 rDocShell.PostPaint( nPaintStartCol, nPaintStartRow,
i, nPaintEndCol, nPaintEndRow,
i+nScenarioCount, PaintPartFlags::Top );
2215 rDocShell.PostPaint( nPaintStartCol, nPaintStartRow,
i, nPaintEndCol, nPaintEndRow,
i+nScenarioCount, nPaintFlags, nExtFlags );
2222 while( !qIncreaseRange.empty() )
2224 ScRange aRange = qIncreaseRange.back();
2228 MergeCells(aMergeOption,
false,
true,
true);
2229 qIncreaseRange.pop_back();
2234 pViewSh->
MarkRange( aTargetRange,
false );
2235 pViewSh->
SetCursor( nCursorCol, nCursorRow );
2239 rDocShell.GetUndoManager()->LeaveListAction();
2240 rDocShell.GetUndoManager()->RemoveLastUndoAction();
2242 pRefUndoDoc.reset();
2244 rDocShell.ErrorMessage(STR_INSERT_FULL);
2277 if (rDocShell.GetDocument().GetChangeTrack() &&
2283 SAL_WARN(
"sc.ui",
"ScDocFunc::DeleteCells - no change-tracking of partial cell shift");
2296 OSL_FAIL(
"invalid row in DeleteCells");
2301 SCCOL nPaintStartCol = nStartCol;
2302 SCROW nPaintStartRow = nStartRow;
2303 SCCOL nPaintEndCol = nEndCol;
2304 SCROW nPaintEndRow = nEndRow;
2307 bool bRecord =
true;
2322 if( nCount == nEndTab+1 )
2324 aMark.SelectTable(
i,
true);
2332 for (
const auto& rTab : aMark)
2334 if (rTab >= nTabCount)
2341 SCTAB nSelCount = aMark.GetSelectCount();
2343 SCCOL nUndoStartCol = nStartCol;
2344 SCROW nUndoStartRow = nStartRow;
2345 SCCOL nUndoEndCol = nEndCol;
2346 SCROW nUndoEndRow = nEndRow;
2348 ScRange aExtendMergeRange( rRange );
2354 nUndoEndCol = aExtendMergeRange.
aEnd.
Col();
2355 nUndoEndRow = aExtendMergeRange.
aEnd.
Row();
2356 nPaintEndCol = nUndoEndCol;
2357 nPaintEndRow = nUndoEndRow;
2363 nUndoEndCol = rDoc.
MaxCol();
2368 nUndoEndRow = rDoc.
MaxRow();
2372 SCCOL nEditTestEndX = nUndoEndCol;
2374 nEditTestEndX = rDoc.
MaxCol();
2375 SCROW nEditTestEndY = nUndoEndRow;
2377 nEditTestEndY = rDoc.
MaxRow();
2393 rDoc, nUndoStartCol, nUndoStartRow, nEditTestEndX, nEditTestEndY, aMark);
2403 if (!canDeleteCellsByPivot(rRange, aMark, eCmd, rDoc))
2406 rDocShell.ErrorMessage(STR_NO_INSERT_DELETE_OVER_PIVOT_TABLE);
2413 SCCOL nExtendStartCol = nUndoStartCol;
2414 SCROW nExtendStartRow = nUndoStartRow;
2415 bool bNeedRefresh =
false;
2419 ::std::vector<ScRange> qDecreaseRange;
2420 bool bDeletingMerge =
false;
2421 OUString aUndo =
ScResId( STR_UNDO_DELETECELLS );
2426 nViewShellId = pViewSh->GetViewShellId();
2427 rDocShell.GetUndoManager()->EnterListAction( aUndo, aUndo, 0, nViewShellId );
2429 std::unique_ptr<ScUndoRemoveMerge> pUndoRemoveMerge;
2431 for (
const SCTAB i : aMark)
2438 SCCOL nMergeStartCol = nUndoStartCol;
2439 SCROW nMergeStartRow = nUndoStartRow;
2440 SCCOL nMergeEndCol = nMergeTestEndCol;
2441 SCROW nMergeEndRow = nMergeTestEndRow;
2443 rDoc.
ExtendMerge( nMergeStartCol, nMergeStartRow, nMergeEndCol, nMergeEndRow,
i );
2444 rDoc.
ExtendOverlapped( nMergeStartCol, nMergeStartRow, nMergeEndCol, nMergeEndRow,
i );
2445 if( ( eCmd ==
DelCellCmd::CellsUp && ( nMergeStartCol != nUndoStartCol || nMergeEndCol != nMergeTestEndCol))||
2446 ( eCmd ==
DelCellCmd::CellsLeft && ( nMergeStartRow != nUndoStartRow || nMergeEndRow != nMergeTestEndRow)))
2449 rDocShell.ErrorMessage(STR_MSSG_DELETECELLS_0);
2450 rDocShell.GetUndoManager()->LeaveListAction();
2454 nExtendStartCol = nMergeStartCol;
2455 nExtendStartRow = nMergeStartRow;
2456 SCCOL nTestCol = -1;
2457 SCROW nTestRow1 = -1;
2458 SCROW nTestRow2 = -1;
2460 ScDocAttrIterator aTestIter( rDoc,
i, nUndoStartCol, nUndoStartRow, nMergeTestEndCol, nMergeTestEndRow );
2461 ScRange aExtendRange( nUndoStartCol, nUndoStartRow,
i, nMergeTestEndCol, nMergeTestEndRow,
i );
2463 while ( ( pPattern = aTestIter.
GetNext( nTestCol, nTestRow1, nTestRow2 ) ) !=
nullptr )
2470 ScRange aRange( nTestCol, nTestRow1,
i );
2474 if( nTestRow1 < nTestRow2 && nNewFlags ==
ScMF::Hor )
2476 for(
SCROW nTestRow = nTestRow1; nTestRow <= nTestRow2; nTestRow++ )
2478 ScRange aTestRange( nTestCol, nTestRow,
i );
2482 if( !aExtendRange.
Contains( aMergeRange ) )
2484 qDecreaseRange.push_back( aTestRange );
2485 bDeletingMerge =
true;
2492 if( !aExtendRange.
Contains( aMergeRange ) )
2494 qDecreaseRange.push_back( aRange );
2496 bDeletingMerge =
true;
2501 if( bDeletingMerge )
2506 nStartRow = aExtendMergeRange.
aStart.
Row();
2507 nEndRow = aExtendMergeRange.
aEnd.
Row();
2508 bNeedRefresh =
true;
2512 nEndCol = aExtendMergeRange.
aEnd.
Col();
2523 nStartCol = aExtendMergeRange.
aStart.
Col();
2524 nEndCol = aExtendMergeRange.
aEnd.
Col();
2527 nEndRow = aExtendMergeRange.
aEnd.
Row();
2528 bNeedRefresh =
true;
2537 if( !qDecreaseRange.empty() )
2539 if (bRecord && !pUndoRemoveMerge)
2542 pUndoDoc->InitUndo( rDoc, *aMark.begin(), *aMark.rbegin());
2543 pUndoRemoveMerge.reset(
new ScUndoRemoveMerge( &rDocShell, rRange, std::move(pUndoDoc) ));
2546 for(
const ScRange& aRange : qDecreaseRange )
2550 UnmergeCells( aRange, bRecord, pUndoRemoveMerge.get() );
2558 rDocShell.ErrorMessage(STR_MSSG_DELETECELLS_0);
2559 rDocShell.GetUndoManager()->LeaveListAction();
2565 if (bRecord && pUndoRemoveMerge)
2567 rDocShell.GetUndoManager()->AddUndoAction( std::move(pUndoRemoveMerge));
2575 std::unique_ptr<ScDocument> pRefUndoDoc;
2576 std::unique_ptr<ScRefUndoData> pUndoData;
2584 for (
const auto& rTab : aMark)
2586 if (rTab >= nTabCount)
2589 SCTAB nScenarioCount = 0;
2594 rDoc.
CopyToDocument( nUndoStartCol, nUndoStartRow, rTab, nUndoEndCol, nUndoEndRow, rTab+nScenarioCount,
2599 pRefUndoDoc->InitUndo( rDoc, 0, nTabCount-1 );
2606 sal_uInt16 nExtFlags = 0;
2607 for (
const auto& rTab : aMark)
2609 if (rTab >= nTabCount)
2612 rDocShell.UpdatePaintExt( nExtFlags, nStartCol, nStartRow, rTab, nEndCol, nEndRow, rTab );
2632 bool bUndoOutline =
false;
2636 rDoc.
DeleteRow( nStartCol, 0, nEndCol,
MAXTAB, nStartRow, static_cast<SCSIZE>(nEndRow-nStartRow+1), pRefUndoDoc.get(),
nullptr, &aFullMark );
2637 nPaintEndRow = rDoc.
MaxRow();
2640 rDoc.
DeleteRow( 0, 0, rDoc.
MaxCol(),
MAXTAB, nStartRow,
static_cast<SCSIZE>(nEndRow-nStartRow+1), pRefUndoDoc.get(), &bUndoOutline, &aFullMark );
2642 nPaintEndCol = rDoc.
MaxCol();
2643 nPaintEndRow = rDoc.
MaxRow();
2647 rDoc.
DeleteCol( nStartRow, 0, nEndRow,
MAXTAB, nStartCol, static_cast<SCSIZE>(nEndCol-nStartCol+1), pRefUndoDoc.get(),
nullptr, &aFullMark );
2648 nPaintEndCol = rDoc.
MaxCol();
2651 rDoc.
DeleteCol( 0, 0, rDoc.
MaxRow(),
MAXTAB, nStartCol,
static_cast<SCSIZE>(nEndCol-nStartCol+1), pRefUndoDoc.get(), &bUndoOutline, &aFullMark );
2653 nPaintEndRow = rDoc.
MaxRow();
2654 nPaintEndCol = rDoc.
MaxCol();
2658 OSL_FAIL(
"Wrong code at deleting");
2666 for (
const auto& rTab : aFullMark)
2668 if (rTab >= nTabCount)
2671 pRefUndoDoc->DeleteAreaTab(nUndoStartCol,nUndoStartRow,nUndoEndCol,nUndoEndRow, rTab,
InsertDeleteFlags::ALL);
2675 pUndoDoc->AddUndoTab( 0, nTabCount-1 );
2678 pRefUndoDoc->CopyToDocument(0,0,0,rDoc.
MaxCol(),rDoc.
MaxRow(),
MAXTAB,
InsertDeleteFlags::FORMULA,
false,*pUndoDoc,
nullptr,
false);
2679 pRefUndoDoc.reset();
2681 std::unique_ptr<SCTAB[]> pTabs(
new SCTAB[nSelCount]);
2682 std::unique_ptr<SCTAB[]> pScenarios(
new SCTAB[nSelCount]);
2685 for (
const auto& rTab : aMark)
2687 if (rTab >= nTabCount)
2694 pScenarios[nUndoPos] = nCount;
2695 pTabs[nUndoPos] = rTab;
2699 if( !bDeletingMerge )
2701 rDocShell.GetUndoManager()->LeaveListAction();
2704 rDocShell.GetUndoManager()->AddUndoAction( std::make_unique<ScUndoDeleteCells>(
2705 &rDocShell,
ScRange( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab ),
2706 nUndoPos, std::move(pTabs), std::move(pScenarios),
2707 eCmd, std::move(pUndoDoc), std::move(pUndoData) ) );
2713 while( !qDecreaseRange.empty() )
2715 ScRange aRange = qDecreaseRange.back();
2717 sal_Int32 nDecreaseRowCount = 0;
2718 sal_Int32 nDecreaseColCount = 0;
2722 nDecreaseRowCount = nEndRow-nStartRow+1;
2724 nDecreaseRowCount = aRange.
aEnd.
Row()-nStartRow+1;
2726 nDecreaseRowCount = aRange.
aEnd.
Row()-nEndRow+1;
2731 nDecreaseColCount = nEndCol-nStartCol+1;
2733 nDecreaseColCount = aRange.
aEnd.
Col()-nStartCol+1;
2735 nDecreaseColCount = aRange.
aEnd.
Col()-nEndCol+1;
2755 MergeCells( aMergeOption,
false,
true,
true );
2757 qDecreaseRange.pop_back();
2760 if( bDeletingMerge )
2761 rDocShell.GetUndoManager()->LeaveListAction();
2764 nMergeTestEndCol = rDoc.
MaxCol();
2766 nMergeTestEndRow = rDoc.
MaxRow();
2775 rDoc.
ApplyPatternArea( nExtendStartCol, nExtendStartRow, nMergeTestEndCol, nMergeTestEndRow, aMark, aPattern );
2777 for (
const auto& rTab : aMark)
2779 if (rTab >= nTabCount)
2782 SCTAB nScenarioCount = 0;
2787 ScRange aMergedRange( nExtendStartCol, nExtendStartRow, rTab, nMergeTestEndCol, nMergeTestEndRow, rTab+nScenarioCount );
2792 for (
const auto& rTab : aMark)
2794 if (rTab >= nTabCount)
2797 rDoc.
RefreshAutoFilter( nExtendStartCol, nExtendStartRow, nMergeTestEndCol, nMergeTestEndRow, rTab );
2800 for (
const auto& rTab : aMark)
2802 if (rTab >= nTabCount)
2810 rDocShell.UpdatePaintExt( nExtFlags, nPaintStartCol, nPaintStartRow, rTab, nPaintEndCol, nPaintEndRow, rTab );
2812 SCTAB nScenarioCount = 0;
2818 if ( eCmd ==
DelCellCmd::Rows || !AdjustRowHeight(
ScRange( 0, nPaintStartRow, rTab, rDoc.
MaxCol(), nPaintEndRow, rTab+nScenarioCount ),
true, bApi) )
2819 rDocShell.PostPaint( nPaintStartCol, nPaintStartRow, rTab, nPaintEndCol, nPaintEndRow, rTab+nScenarioCount, nPaintFlags, nExtFlags );
2824 lcl_PaintAbove( rDocShell,
ScRange( nPaintStartCol, nPaintStartRow, rTab, nPaintEndCol, nPaintEndRow, rTab+nScenarioCount) );
2826 rDocShell.PostPaint( nPaintStartCol, nPaintStartRow, rTab, nPaintEndCol, nPaintEndRow, rTab+nScenarioCount, PaintPartFlags::Top );
2853 bool bCut,
bool bRecord,
bool bPaint,
bool bApi )
2870 OSL_FAIL(
"invalid row in MoveBlock");
2875 bool bScenariosAdded =
false;
2880 if ( nDestTab == nStartTab && !rDoc.
IsScenario(nEndTab) )
2881 while ( nEndTab+1 < nTabCount && rDoc.
IsScenario(nEndTab+1) )
2884 bScenariosAdded =
true;
2887 SCTAB nSrcTabCount = nEndTab-nStartTab+1;
2888 SCTAB nDestEndTab = nDestTab+nSrcTabCount-1;
2894 for (nTab=nStartTab; nTab<=nEndTab; nTab++)
2896 aSourceMark.SetMarkArea( rSource );
2906 ScClipParam aClipParam(
ScRange(nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nStartTab), bCut);
2907 rDoc.
CopyToClip(aClipParam, pClipDoc.get(), &aSourceMark, bScenariosAdded,
true);
2911 SCCOL nOldEndCol = nEndCol;
2912 SCROW nOldEndRow = nEndRow;
2913 bool bClipOver =
false;
2914 for (nTab=nStartTab; nTab<=nEndTab; nTab++)
2916 SCCOL nTmpEndCol = nOldEndCol;
2917 SCROW nTmpEndRow = nOldEndRow;
2918 if (rDoc.
ExtendMerge( nStartCol, nStartRow, nTmpEndCol, nTmpEndRow, nTab ))
2920 if ( nTmpEndCol > nEndCol ) nEndCol = nTmpEndCol;
2921 if ( nTmpEndRow > nEndRow ) nEndRow = nTmpEndRow;
2924 SCCOL nDestEndCol = nDestCol + ( nOldEndCol-nStartCol );
2925 SCROW nDestEndRow = nDestRow + ( nOldEndRow-nStartRow );
2927 SCCOL nUndoEndCol = nDestCol + ( nEndCol-nStartCol );
2928 SCROW nUndoEndRow = nDestRow + ( nEndRow-nStartRow );
2930 bool bIncludeFiltered = bCut;
2931 if ( !bIncludeFiltered )
2937 pClipDoc->GetClipArea( nClipX, nClipY,
false );
2938 SCROW nUndoAdd = nUndoEndRow - nDestEndRow;
2939 nDestEndRow = nDestRow + nClipY;
2940 nUndoEndRow = nDestEndRow + nUndoAdd;
2946 rDocShell.ErrorMessage(STR_PASTE_FULL);
2953 for (nTab=nDestTab; nTab<=nDestEndTab; nTab++)
2954 aTester.
TestBlock( rDoc, nTab, nDestCol,nDestRow, nUndoEndCol,nUndoEndRow );
2956 for (nTab=nStartTab; nTab<=nEndTab; nTab++)
2957 aTester.
TestBlock( rDoc, nTab, nStartCol,nStartRow, nEndCol,nEndRow );
2968 if (bClipOver && !bCut)
2969 if (rDoc.
HasAttrib( nDestCol,nDestRow,nDestTab, nUndoEndCol,nUndoEndRow,nDestEndTab,
2973 rDocShell.ErrorMessage(STR_MSSG_MOVEBLOCKTO_0);
2979 sal_uInt16 nSourceExt = 0;
2980 rDocShell.UpdatePaintExt( nSourceExt, nStartCol,nStartRow,nStartTab, nEndCol,nEndRow,nEndTab );
2981 sal_uInt16 nDestExt = 0;
2982 rDocShell.UpdatePaintExt( nDestExt, nDestCol,nDestRow,nDestTab, nDestEndCol,nDestEndRow,nDestEndTab );
2990 bool bWholeCols = ( nStartRow == 0 && nEndRow == rDoc.
MaxRow() );
2991 bool bWholeRows = ( nStartCol == 0 && nEndCol == rDoc.
MaxCol() );
2995 pUndoDoc->InitUndo( rDoc, nStartTab, nEndTab, bWholeCols, bWholeRows );
2999 rDoc.
CopyToDocument( nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab,
3000 nUndoFlags,
false, *pUndoDoc );
3003 if ( nDestTab != nStartTab )
3004 pUndoDoc->AddUndoTab( nDestTab, nDestEndTab, bWholeCols, bWholeRows );
3006 nDestEndCol, nDestEndRow, nDestEndTab,
3007 nUndoFlags,
false, *pUndoDoc );
3011 bool bSourceHeight =
false;
3015 for (nTab=nStartTab; nTab<=nEndTab; nTab++)
3018 aDelMark.SelectTable( nTab,
true );
3025 if (rDoc.
HasAttrib( nDestCol,nDestRow,nDestTab,
3026 nUndoEndCol,nUndoEndRow,nDestEndTab,
3030 for (nTab=nStartTab; nTab<=nEndTab; nTab++)
3032 SCCOL nTmpEndCol = nEndCol;
3033 SCROW nTmpEndRow = nEndRow;
3034 rDoc.
ExtendMerge( nStartCol, nStartRow, nTmpEndCol, nTmpEndRow, nTab,
true );
3039 rDocShell.ErrorMessage(STR_MSSG_MOVEBLOCKTO_0);
3044 bSourceHeight = AdjustRowHeight( rSource,
false, bApi );
3047 ScRange aPasteDest( nDestCol, nDestRow, nDestTab, nDestEndCol, nDestEndRow, nDestEndTab );
3050 for (nTab=nDestTab; nTab<=nDestEndTab; nTab++)
3052 aDestMark.SetMarkArea( aPasteDest );
3061 pUndoDoc.get(), pClipDoc.get(),
true,
false, bIncludeFiltered);
3064 if ( !bIncludeFiltered && pClipDoc->HasClipFilteredRows() )
3065 UnmergeCells( aPasteDest,
false,
nullptr );
3067 bool bDestHeight = AdjustRowHeight(
3068 ScRange( 0,nDestRow,nDestTab, rDoc.
MaxCol(),nDestEndRow,nDestEndTab ),
3074 if ( pClipDoc->GetDrawLayer() )
3076 nullptr, pClipDoc.get(),
true,
false, bIncludeFiltered );
3080 ScRange aUndoRange(nStartCol, nStartRow, nStartTab, nOldEndCol, nOldEndRow, nEndTab);
3081 ScAddress aDestPos(nDestCol, nDestRow, nDestTab);
3083 rDocShell.GetUndoManager()->AddUndoAction(
3084 std::make_unique<ScUndoDragDrop>(
3085 &rDocShell, aUndoRange, aDestPos, bCut, std::move(pUndoDoc), bScenariosAdded));
3088 SCCOL nDestPaintEndCol = nDestEndCol;
3089 SCROW nDestPaintEndRow = nDestEndRow;
3090 for (nTab=nDestTab; nTab<=nDestEndTab; nTab++)
3092 SCCOL nTmpEndCol = nDestEndCol;
3093 SCROW nTmpEndRow = nDestEndRow;
3094 rDoc.
ExtendMerge( nDestCol, nDestRow, nTmpEndCol, nTmpEndRow, nTab,
true );
3095 if (nTmpEndCol > nDestPaintEndCol) nDestPaintEndCol = nTmpEndCol;
3096 if (nTmpEndRow > nDestPaintEndRow) nDestPaintEndRow = nTmpEndRow;
3100 for (nTab=nStartTab; nTab<=nEndTab; nTab++)
3107 SCCOL nPaintStartX = nDestCol;
3108 SCROW nPaintStartY = nDestRow;
3109 SCCOL nPaintEndX = nDestPaintEndCol;
3110 SCROW nPaintEndY = nDestPaintEndRow;
3113 if ( nStartRow==0 && nEndRow==rDoc.
MaxRow() )
3115 nPaintEndX = rDoc.
MaxCol();
3117 nPaintEndY = rDoc.
MaxRow();
3120 if ( bDestHeight || ( nStartCol == 0 && nEndCol == rDoc.
MaxCol() ) )
3122 nPaintEndY = rDoc.
MaxRow();
3124 nPaintEndX = rDoc.
MaxCol();
3127 if ( bScenariosAdded )
3131 nPaintEndX = rDoc.
MaxCol();
3132 nPaintEndY = rDoc.
MaxRow();
3135 rDocShell.PostPaint( nPaintStartX,nPaintStartY,nDestTab,
3136 nPaintEndX,nPaintEndY,nDestEndTab, nFlags, nSourceExt | nDestExt );
3142 nPaintStartX = nStartCol;
3143 nPaintStartY = nStartRow;
3144 nPaintEndX = nEndCol;
3145 nPaintEndY = nEndRow;
3148 if ( bSourceHeight )
3150 nPaintEndY = rDoc.
MaxRow();
3152 nPaintEndX = rDoc.
MaxCol();
3155 if ( bScenariosAdded )
3159 nPaintEndX = rDoc.
MaxCol();
3160 nPaintEndY = rDoc.
MaxRow();
3163 rDocShell.PostPaint( nPaintStartX,nPaintStartY,nStartTab,
3164 nPaintEndX,nPaintEndY,nEndTab, nFlags, nSourceExt );
3177 uno::Reference< lang::XMultiServiceFactory> xSF(rDocSh.
GetModel(), uno::UNO_QUERY);
3178 uno::Reference< container::XNameAccess > xVBACodeNamedObjectAccess;
3179 uno::Reference< uno::XInterface > xDocModuleApiObject;
3182 xVBACodeNamedObjectAccess.set( xSF->createInstance(
"ooo.vba.VBAObjectModuleObjectProvider"), uno::UNO_QUERY );
3183 xDocModuleApiObject.set( xVBACodeNamedObjectAccess->getByName( sCodeName ), uno::UNO_QUERY );
3185 return xDocModuleApiObject;
3191 script::ModuleInfo sModuleInfo;
3192 sModuleInfo.ModuleType = script::ModuleType::DOCUMENT;
3200 uno::Reference< script::XLibraryContainer > xLibContainer = rDocSh.
GetBasicContainer();
3201 OSL_ENSURE( xLibContainer.is(),
"No BasicContainer!" );
3203 uno::Reference< container::XNameContainer > xLib;
3204 if( xLibContainer.is() )
3206 OUString aLibName(
"Standard" );
3207 #if HAVE_FEATURE_SCRIPTING
3213 uno::Any aLibAny = xLibContainer->getByName( aLibName );
3221 OUString genModuleName =
"Sheet1";
3222 while( xLib->hasByName( genModuleName ) )
3223 genModuleName =
"Sheet" + OUString::number( ++nNum );
3226 OUString sTmpSource = sSource;
3227 if ( sTmpSource.isEmpty() )
3228 sTmpSource =
"Rem Attribute VBA_ModuleType=VBADocumentModule\nOption VBASupport 1\n";
3229 aSourceAny <<= sTmpSource;
3230 uno::Reference< script::vba::XVBAModuleInfo > xVBAModuleInfo( xLib, uno::UNO_QUERY );
3231 if ( xVBAModuleInfo.is() )
3235 xVBAModuleInfo->insertModuleInfo( genModuleName, sModuleInfo );
3236 xLib->insertByName( genModuleName, aSourceAny );
3242 uno::Reference< script::XLibraryContainer > xLibContainer = rDocSh.
GetBasicContainer();
3243 OSL_ENSURE( xLibContainer.is(),
"No BasicContainer!" );
3245 uno::Reference< container::XNameContainer > xLib;
3246 if( xLibContainer.is() )
3248 OUString aLibName(
"Standard" );
3249 #if HAVE_FEATURE_SCRIPTING
3255 uno::Any aLibAny = xLibContainer->getByName( aLibName );
3260 uno::Reference< script::vba::XVBAModuleInfo > xVBAModuleInfo( xLib, uno::UNO_QUERY );
3261 if( xLib->hasByName( sModuleName ) )
3262 xLib->removeByName( sModuleName );
3263 if ( xVBAModuleInfo.is() && xVBAModuleInfo->hasModuleInfo(sModuleName) )
3264 xVBAModuleInfo->removeModuleInfo( sModuleName );
3271 bool bSuccess =
false;
3280 bool bInsertDocModule =
false;
3282 if( !rDocShell.GetDocument().IsImportingXML() )
3286 if ( bInsertDocModule || ( bRecord && !rDoc.
IsUndoEnabled() ) )
3293 bool bAppend = ( nTab >= nTabCount );
3300 rDocShell.GetUndoManager()->AddUndoAction(
3301 std::make_unique<ScUndoInsertTab>( &rDocShell, nTab, bAppend, rName));
3304 if( bInsertDocModule )
3310 rDocShell.PostPaintExtras();
3316 rDocShell.ErrorMessage(STR_TABINSERT_ERROR);
3327 bool bSuccess =
false;
3334 bool bWasLinked = rDoc.
IsLinked(nTab);
3336 std::unique_ptr<ScRefUndoData> pUndoData;
3342 pUndoDoc->InitUndo( rDoc, nTab, nTab,
true,
true );
3343 pUndoDoc->AddUndoTab( 0, nCount-1 );
3347 rDoc.
GetName( nTab, aOldName );
3348 pUndoDoc->RenameTab( nTab, aOldName );
3357 pUndoDoc->SetScenario( nTab,
true );
3362 pUndoDoc->SetScenarioData( nTab, aComment, aColor, nScenFlags );
3364 pUndoDoc->SetActiveScenario( nTab, bActive );
3366 pUndoDoc->SetVisible( nTab, rDoc.
IsVisible( nTab ) );
3369 pUndoDoc->SetSheetEvents( nTab, std::unique_ptr<ScSheetEvents>(pSheetEvents ?
new ScSheetEvents(*pSheetEvents) :
nullptr) );
3381 vector<SCTAB> theTabs;
3382 theTabs.push_back(nTab);
3383 rDocShell.GetUndoManager()->AddUndoAction(
3384 std::make_unique<ScUndoDeleteTab>( &rDocShell, theTabs, std::move(pUndoDoc), std::move(pUndoData) ));
3399 rDocShell.UpdateLinks();
3400 SfxBindings* pBindings = rDocShell.GetViewBindings();
3405 rDocShell.PostPaintExtras();
3409 pSfxApp->Broadcast(
SfxHint( SfxHintId::ScTablesChanged ) );
3410 pSfxApp->Broadcast(
SfxHint( SfxHintId::ScDbAreasChanged ) );
3411 pSfxApp->Broadcast(
SfxHint( SfxHintId::ScAreaLinksChanged ) );
3422 if ( rDoc.
IsVisible( nTab ) == bVisible )
3428 rDocShell.ErrorMessage(STR_PROTECTIONERR);
3438 sal_uInt16 nVisCount = 0;
3440 for (
SCTAB i=0;
i<nCount && nVisCount<2;
i++)
3447 rDocShell.ErrorMessage(STR_PROTECTIONERR);
3455 std::vector<SCTAB> undoTabs { nTab };
3456 rDocShell.GetUndoManager()->AddUndoAction( std::make_unique<ScUndoShowHideTab>( &rDocShell, std::move(undoTabs), bVisible ) );
3483 rDocShell.GetUndoManager()->AddUndoAction( std::make_unique<ScUndoLayoutRTL>( &rDocShell, nTab, bRTL ) );
3489 SfxBindings* pBindings = rDocShell.GetViewBindings();
3507 rDocShell.ErrorMessage(STR_PROTECTIONERR);
3513 bool bSuccess =
false;
3520 rDocShell.GetUndoManager()->AddUndoAction(
3521 std::make_unique<ScUndoRenameTab>( &rDocShell, nTab, sOldName, rName));
3523 rDocShell.PostPaintExtras();
3542 rDocShell.ErrorMessage(STR_PROTECTIONERR);
3548 bool bSuccess =
false;
3556 rDocShell.GetUndoManager()->AddUndoAction(
3557 std::make_unique<ScUndoTabColor>( &rDocShell, nTab, aOldTabBgColor, rColor));
3559 rDocShell.PostPaintExtras();
3573 bool bRecord =
true;
3580 rDocShell.ErrorMessage(STR_PROTECTIONERR);
3585 Color aNewTabBgColor;
3586 bool bSuccess =
true;
3587 size_t nTabProtectCount = 0;
3588 size_t nTabListCount = rUndoTabColorList.size();
3589 for (
size_t i = 0;
i < nTabListCount; ++
i )
3610 if ( nTabProtectCount == nTabListCount )
3613 rDocShell.ErrorMessage(STR_PROTECTIONERR);
3621 rDocShell.GetUndoManager()->AddUndoAction(
3622 std::make_unique<ScUndoTabColor>( &rDocShell, std::vector(rUndoTabColorList)));
3624 rDocShell.PostPaintExtras();
3645 sal_uInt16 nTwips = rDoc.
GetOptimalColWidth( nCol, nTab, pDev, nPPTX, nPPTY, aOne, aOne,
3652 bool bWidth,
const std::vector<sc::ColRowSpan>& rRanges,
SCTAB nTab,
3653 ScSizeMode eMode, sal_uInt16 nSizeTwips,
bool bRecord,
bool bApi )
3657 if (rRanges.empty())
3668 rDocShell.ErrorMessage(STR_PROTECTIONERR);
3672 SCCOLROW nStart = rRanges[0].mnStart;
3681 std::unique_ptr<ScOutlineTable> pUndoTab;
3682 std::vector<sc::ColRowSpan> aUndoRanges;
3691 pUndoDoc->InitUndo( rDoc, nTab, nTab,
true );
3696 pUndoDoc->InitUndo( rDoc, nTab, nTab,
false,
true );
3700 aUndoRanges = rRanges;
3708 bool bOutline =
false;
3712 SCCOLROW nStartNo = rRange.mnStart;
3724 for (
SCROW nRow=nStartNo; nRow<=nEndNo; nRow++)
3727 SCROW nLastRow = -1;
3728 bool bHidden = rDoc.
RowHidden(nRow, nTab,
nullptr, &nLastRow);
3730 rDoc.
SetRowFlags( nRow, nTab, nOld & ~CRFlags::ManualSize );
3741 rDoc.
ShowRows( nStartNo, nEndNo, nTab,
true );
3754 rDoc.
ShowRows( nStartNo, nEndNo, nTab, nSizeTwips != 0 );
3758 rDoc.
ShowRows( nStartNo, nEndNo, nTab,
true );
3763 for (
SCCOL nCol=static_cast<SCCOL>(nStartNo); nCol<=static_cast<SCCOL>(nEndNo); nCol++)
3767 sal_uInt16 nThisSize = nSizeTwips;
3770 nThisSize = nSizeTwips +
3776 rDoc.
ShowCol( nCol, nTab, bShow );
3787 static_cast<SCCOL>(nStartNo),
3788 static_cast<SCCOL>(nEndNo), nTab, bShow );
3791 static_cast<SCROW>(nStartNo),
3792 static_cast<SCROW>(nEndNo), nTab, bShow );
3804 rDocShell.GetUndoManager()->AddUndoAction(
3805 std::make_unique<ScUndoWidthOrHeight>(
3806 &rDocShell, aMark, nStart, nTab, nEnd, nTab, std::move(pUndoDoc),
3807 std::move(aUndoRanges), std::move(pUndoTab), eMode, nSizeTwips, bWidth));
3823 bool bRecord,
bool bSetModified )
3831 SfxBindings* pBindings = rDocShell.GetViewBindings();
3834 static_cast<SCCOLROW>(rPos.
Row());
3839 rDoc.
HasColBreak(static_cast<SCCOL>(nPos), nTab) :
3845 rDocShell.GetUndoManager()->AddUndoAction(
3846 std::make_unique<ScUndoPageBreak>( &rDocShell, rPos.
Col(), rPos.
Row(), nTab, bColumn, true ) );
3849 rDoc.
SetColBreak(static_cast<SCCOL>(nPos), nTab,
false,
true);
3851 rDoc.
SetRowBreak(static_cast<SCROW>(nPos), nTab,
false,
true);
3877 pBindings->
Invalidate( FID_DEL_MANUALBREAKS );
3886 bool bRecord,
bool bSetModified )
3894 SfxBindings* pBindings = rDocShell.GetViewBindings();
3897 static_cast<SCCOLROW>(rPos.
Row());
3901 nBreak = rDoc.
HasColBreak(static_cast<SCCOL>(nPos), nTab);
3903 nBreak = rDoc.
HasRowBreak(static_cast<SCROW>(nPos), nTab);
3909 rDocShell.GetUndoManager()->AddUndoAction(
3910 std::make_unique<ScUndoPageBreak>( &rDocShell, rPos.
Col(), rPos.
Row(), nTab, bColumn,
false ) );
3913 rDoc.
RemoveColBreak(static_cast<SCCOL>(nPos), nTab,
false,
true);
3915 rDoc.
RemoveRowBreak(static_cast<SCROW>(nPos), nTab,
false,
true);
3940 pBindings->
Invalidate( FID_DEL_MANUALBREAKS );
3952 std::unique_ptr<ScTableProtection>
p;
3956 p = std::make_unique<ScTableProtection>(rProtect);
3965 p = std::make_unique<ScTableProtection>(*pProtect);
3967 rDocShell.GetUndoManager()->AddUndoAction(
3968 std::make_unique<ScUndoTabProtect>(&rDocShell, nTab, std::move(p)));
3973 if (
ScTabViewShell* pTabViewShell = dynamic_cast<ScTabViewShell*>(fr->GetViewShell()))
3974 pTabViewShell->SetTabProtectionSymbol(nTab, rProtect.
isProtected());
3975 rDocShell.PostPaintGridAll();
3984 std::unique_ptr<ScDocProtection>
p;
3988 p = std::make_unique<ScDocProtection>(rProtect);
3997 p = std::make_unique<ScDocProtection>(*pProtect);
3999 rDocShell.GetUndoManager()->AddUndoAction(
4000 std::make_unique<ScUndoDocProtect>(&rDocShell, std::move(p)));
4004 rDocShell.PostPaintGridAll();
4017 ProtectDocument(aProtection);
4024 const ScTableProtection* pOldProtection = rDocShell.GetDocument().GetTabProtection(nTab);
4026 pNewProtection->setProtected(
true);
4027 pNewProtection->setPassword(rPassword);
4028 ProtectSheet(nTab, *pNewProtection);
4051 VclMessageType::Info, VclButtonsType::Ok,
4052 ScResId(SCSTR_WRONGPASSWORD)));
4060 ProtectDocument(aNewProtection);
4076 VclMessageType::Info, VclButtonsType::Ok,
4077 ScResId(SCSTR_WRONGPASSWORD)));
4085 ProtectSheet(nTab, aNewProtection);
4098 if (!aTester.IsEditable())
4101 rDocShell.ErrorMessage(aTester.GetMessageId());
4120 pUndoDoc->InitUndo( rDoc, nStartTab, nEndTab );
4123 rDocShell.GetUndoManager()->AddUndoAction(
4124 std::make_unique<ScUndoClearItems>( &rDocShell, aMultiMark, std::move(pUndoDoc), pWhich ) );
4142 if (!aTester.IsEditable())
4145 rDocShell.ErrorMessage(aTester.GetMessageId());
4157 pUndoDoc->InitUndo( rDoc, nStartTab, nStartTab );
4158 for (
const auto& rTab : rMark)
4160 if (rTab >= nTabCount)
4163 if (rTab != nStartTab)
4164 pUndoDoc->AddUndoTab( rTab, rTab );
4167 ScRange aCopyRange = aMarkRange;
4172 rDocShell.GetUndoManager()->AddUndoAction(
4173 std::make_unique<ScUndoIndent>( &rDocShell, rMark, std::move(pUndoDoc), bIncrement ) );
4181 SfxBindings* pBindings = rDocShell.GetViewBindings();
4189 pBindings->
Invalidate( SID_ATTR_PARA_ADJUST_LEFT );
4190 pBindings->
Invalidate( SID_ATTR_PARA_ADJUST_RIGHT );
4191 pBindings->
Invalidate( SID_ATTR_PARA_ADJUST_BLOCK );
4192 pBindings->
Invalidate( SID_ATTR_PARA_ADJUST_CENTER);
4194 pBindings->
Invalidate( SID_ALIGN_ANY_HDEFAULT );
4196 pBindings->
Invalidate( SID_ALIGN_ANY_HCENTER );
4197 pBindings->
Invalidate( SID_ALIGN_ANY_RIGHT );
4198 pBindings->
Invalidate( SID_ALIGN_ANY_JUSTIFIED );
4205 sal_uInt16 nFormatNo,
bool bApi )
4217 bool bRecord =
true;
4225 for (
SCTAB nTab=nStartTab; nTab<=nEndTab; nTab++)
4230 ScEditableTester aTester( rDoc, nStartCol,nStartRow, nEndCol,nEndRow, aMark );
4242 pUndoDoc->InitUndo( rDoc, nStartTab, nStartTab, bSize, bSize );
4243 for (
const auto& rTab : aMark)
4245 if (rTab >= nTabCount)
4248 if (rTab != nStartTab)
4249 pUndoDoc->AddUndoTab( rTab, rTab, bSize, bSize );
4266 rDoc.
AutoFormat( nStartCol, nStartRow, nEndCol, nEndRow, nFormatNo, aMark );
4270 std::vector<sc::ColRowSpan> aCols(1,
sc::ColRowSpan(nStartCol,nEndCol));
4271 std::vector<sc::ColRowSpan> aRows(1,
sc::ColRowSpan(nStartRow,nEndRow));
4273 for (
const auto& rTab : aMark)
4275 if (rTab >= nTabCount)
4279 SetWidthOrHeight(
false, aRows, rTab,
SC_SIZE_VISOPT, 0,
false,
false);
4280 rDocShell.PostPaint( 0,0,rTab, rDoc.
MaxCol(),rDoc.
MaxRow(),rTab,
4286 for (
const auto& rTab : aMark)
4288 if (rTab >= nTabCount)
4291 bool bAdj = AdjustRowHeight(
ScRange(nStartCol, nStartRow, rTab,
4292 nEndCol, nEndRow, rTab),
false, bApi );
4294 rDocShell.PostPaint( 0,nStartRow,rTab, rDoc.
MaxCol(),rDoc.
MaxRow(),rTab,
4297 rDocShell.PostPaint( nStartCol, nStartRow, rTab,
4304 rDocShell.GetUndoManager()->AddUndoAction(
4305 std::make_unique<ScUndoAutoFormat>( &rDocShell, rRange, std::move(pUndoDoc), aMark, bSize, nFormatNo ) );
4317 const ScTokenArray* pTokenArray,
const OUString& rString,
bool bApi,
bool bEnglish,
4325 bool bSuccess =
false;
4339 for (
SCTAB nTab=nStartTab; nTab<=nEndTab; nTab++)
4343 ScEditableTester aTester( rDoc, nStartCol,nStartRow, nEndCol,nEndRow, aMark );
4355 pUndoDoc->InitUndo( rDoc, nStartTab, nEndTab );
4363 aMark, OUString(), pTokenArray, eGrammar);
4371 aMark, OUString(), &aCode, eGrammar);
4377 std::unique_ptr<ScTokenArray> pCode = aComp.
CompileString( rString );
4379 aMark, OUString(), pCode.get(), eGrammar);
4383 aMark, rString,
nullptr, eGrammar);
4388 rDocShell.GetUndoManager()->AddUndoAction(
4389 std::make_unique<ScUndoEnterMatrix>( &rDocShell, rRange, std::move(pUndoDoc), rString ) );
4393 rDocShell.PostPaint( nStartCol,nStartRow,nStartTab,nEndCol,nEndRow,nEndTab,
PaintPartFlags::Grid );
4409 bool bSuccess =
false;
4426 for (
SCTAB nTab=nStartTab; nTab<=nEndTab; nTab++)
4430 ScEditableTester aTester( rDoc, nStartCol,nStartRow, nEndCol,nEndRow, aMark );
4439 pUndoDoc->InitUndo( rDoc, nStartTab, nEndTab );
4442 rDocShell.GetUndoManager()->AddUndoAction(
4443 std::make_unique<ScUndoTabOp>( &rDocShell,
4444 nStartCol, nStartRow, nStartTab,
4445 nEndCol, nEndRow, nEndTab, std::move(pUndoDoc),
4452 rDoc.
InsertTableOp(rParam, nStartCol, nStartRow, nEndCol, nEndRow, aMark);
4453 rDocShell.PostPaintGridAll();
4550 bool bSuccess =
false;
4552 adjustFillRangeForAdjacentCopy(rDoc, aRange, eDir);
4561 bool bRecord =
true;
4570 for (
SCTAB nTab=nStartTab; nTab<=nEndTab; nTab++)
4574 ScEditableTester aTester( rDoc, nStartCol,nStartRow, nEndCol,nEndRow, aMark );
4610 pUndoDoc->InitUndo( rDoc, nDestStartTab, nDestStartTab );
4611 for (
const auto& rTab : aMark)
4613 if (rTab >= nTabCount)
4616 if (rTab != nDestStartTab)
4617 pUndoDoc->AddUndoTab( rTab, rTab );
4620 ScRange aCopyRange = aDestArea;
4631 nProgCount *= nCount;
4633 ScResId(STR_FILL_SERIES_PROGRESS), nProgCount, true );
4638 AdjustRowHeight(aRange,
true, bApi);
4642 rDocShell.GetUndoManager()->AddUndoAction(
4643 std::make_unique<ScUndoAutoFill>( &rDocShell, aDestArea, aSourceArea, std::move(pUndoDoc), aMark,
4647 rDocShell.PostPaintGridAll();
4660 double fStart,
double fStep,
double fMax,
4665 bool bSuccess =
false;
4674 bool bRecord =
true;
4683 for (
SCTAB nTab=nStartTab; nTab<=nEndTab; nTab++)
4687 ScEditableTester aTester( rDoc, nStartCol,nStartRow, nEndCol,nEndRow, aMark );
4702 static_cast<SCSIZE>( aSourceArea.
aEnd.
Row() - aSourceArea.
aStart.
Row() + 1 ) :
4703 static_cast<SCSIZE>( aSourceArea.
aEnd.
Col() - aSourceArea.
aStart.
Col() + 1 );
4704 if ( nCount >= nTotLines )
4705 nCount = nTotLines - 1;
4710 aSourceArea.
aEnd.
SetRow( sal::static_int_cast<SCROW>( aSourceArea.
aEnd.
Row() - nCount ) );
4713 aSourceArea.
aEnd.
SetCol( sal::static_int_cast<SCCOL>( aSourceArea.
aEnd.
Col() - nCount ) );
4730 pUndoDoc->InitUndo( rDoc, nDestStartTab, nDestStartTab );
4731 for (
const auto& rTab : aMark)
4733 if (rTab >= nTabCount)
4736 if (rTab != nDestStartTab)
4737 pUndoDoc->AddUndoTab( rTab, rTab );
4754 rDoc.
SetValue( nValX, nValY, nTab, fStart );
4762 nProgCount *= nCount;
4764 ScResId(STR_FILL_SERIES_PROGRESS), nProgCount, true );
4768 aMark, nCount, eDir, eCmd, eDateCmd, fStep, fMax );
4769 AdjustRowHeight(rRange,
true, bApi);
4771 rDocShell.PostPaintGridAll();
4777 rDocShell.GetUndoManager()->AddUndoAction(
4778 std::make_unique<ScUndoAutoFill>( &rDocShell, aDestArea, aSourceArea, std::move(pUndoDoc), aMark,
4779 eDir, eCmd, eDateCmd, fStart, fStep, fMax) );
4816 for (
SCTAB nTab=nStartTab; nTab<=nEndTab; nTab++)
4826 aDestArea.
aEnd.
SetRow( sal::static_int_cast<SCROW>( aSourceArea.
aEnd.
Row() + nCount ) );
4829 if (nCount > sal::static_int_cast<sal_uLong>( aSourceArea.
aStart.
Row() ))
4831 OSL_FAIL(
"FillAuto: Row < 0");
4837 aDestArea.
aEnd.
SetCol( sal::static_int_cast<SCCOL>( aSourceArea.
aEnd.
Col() + nCount ) );
4840 if (nCount > sal::static_int_cast<sal_uLong>( aSourceArea.
aStart.
Col() ))
4842 OSL_FAIL(
"FillAuto: Col < 0");
4848 OSL_FAIL(
"Wrong direction with FillAuto");
4865 nEndCol, nEndRow, aMark ) )
4868 rDocShell.ErrorMessage(STR_MATRIXFRAGMENTERR);
4886 pUndoDoc->InitUndo( rDoc, nDestStartTab, nDestStartTab );
4887 for (
const auto& rTab : aMark)
4889 if (rTab >= nTabCount)
4892 if (rTab != nDestStartTab)
4893 pUndoDoc->AddUndoTab( rTab, rTab );
4908 nProgCount *= nCount;
4910 ScResId(STR_FILL_SERIES_PROGRESS), nProgCount, true );
4914 aMark, nCount, eDir, eCmd, eDateCmd, fStep, fMax );
4916 AdjustRowHeight(aDestArea,
true, bApi);
4920 rDocShell.GetUndoManager()->AddUndoAction(
4921 std::make_unique<ScUndoAutoFill>( &rDocShell, aDestArea, aSourceArea, std::move(pUndoDoc), aMark,
4922 eDir, eCmd, eDateCmd,
MAXDOUBLE, fStep, fMax) );
4925 rDocShell.PostPaintGridAll();
4942 if ((nStartCol == nEndCol && nStartRow == nEndRow) || rOption.
maTabs.empty())
4954 for (
const auto& rTab : rOption.
maTabs)
4956 ScEditableTester aTester( rDoc, rTab, nStartCol, nStartRow, nEndCol, nEndRow );
4964 if ( rDoc.
HasAttrib( nStartCol, nStartRow, rTab, nEndCol, nEndRow, rTab,
4969 rDocShell.ErrorMessage(STR_MSSG_MERGECELLS_0);
4975 bool bNeedContentsUndo =
false;
4978 bool bIsBlockEmpty = ( nStartRow == nEndRow )
4979 ? rDoc.
IsEmptyData( nStartCol+1,nStartRow, nEndCol,nEndRow, nTab )
4980 : rDoc.
IsEmptyData( nStartCol,nStartRow+1, nStartCol,nEndRow, nTab ) &&
4981 rDoc.
IsEmptyData( nStartCol+1,nStartRow, nEndCol,nEndRow, nTab );
4982 bool bNeedContents = bContents && !bIsBlockEmpty;
4983 bool bNeedEmpty = bEmptyMergedCells && !bIsBlockEmpty && !bNeedContents;
4988 bool bHasNotes = rDoc.
HasNote(nTab, nStartCol, nStartRow, nEndCol, nEndRow);
4992 pUndoDoc->InitUndo(rDoc, nTab1, nTab2);
4995 rDoc.
CopyToDocument( nStartCol, nStartRow, nTab, nEndCol, nEndRow, nTab,
5003 else if ( bNeedEmpty )
5004 rDoc.
DoEmptyBlock( nStartCol,nStartRow, nEndCol,nEndRow, nTab );
5005 rDoc.
DoMerge( nStartCol,nStartRow, nEndCol,nEndRow, nTab );
5013 if ( !AdjustRowHeight(
ScRange( 0,nStartRow,nTab, rDoc.
MaxCol(),nEndRow,nTab ),
true, bApi ) )
5014 rDocShell.PostPaint( nStartCol, nStartRow, nTab,
5016 if (bNeedContents || rOption.
mbCenter)
5018 ScRange aRange(nStartCol, nStartRow, nTab, nEndCol, nEndRow, nTab);
5024 DetectiveMarkInvalid(nTab);
5026 bNeedContentsUndo |= bNeedContents;
5032 rDocShell.GetUndoManager()->AddUndoAction(
5033 std::make_unique<ScUndoMerge>(&rDocShell, rOption, bNeedContentsUndo, std::move(pUndoDoc), std::move(pDrawUndo)) );
5038 SfxBindings* pBindings = rDocShell.GetViewBindings();
5053 for (
SCTAB i = nTab1;
i <= nTab2; ++
i)
5054 aOption.maTabs.insert(
i);
5056 return UnmergeCells(aOption, bRecord, pUndoRemoveMerge);
5063 if (rOption.
maTabs.empty())
5074 assert( pUndoDoc || !pUndoRemoveMerge );
5109 if ( !AdjustRowHeight( aExtended,
true,
true ) )
5114 DetectiveMarkInvalid(nTab);
5119 if (pUndoRemoveMerge)
5127 rDocShell.GetUndoManager()->AddUndoAction(
5128 std::make_unique<ScUndoRemoveMerge>( &rDocShell, rOption,
ScDocumentUniquePtr(pUndoDoc) ) );
5138 SetNewRangeNames( std::unique_ptr<ScRangeName>(
new ScRangeName(rNewRanges)),
true, nTab );
5145 OSL_ENSURE( pNewRanges,
"pNewRanges is 0" );
5160 std::unique_ptr<ScRangeName> pUndoRanges(
new ScRangeName(*pOld));
5161 std::unique_ptr<ScRangeName> pRedoRanges(
new ScRangeName(*pNewRanges));
5162 rDocShell.GetUndoManager()->AddUndoAction(
5163 std::make_unique<ScUndoRangeNames>( &rDocShell, std::move(pUndoRanges), std::move(pRedoRanges), nTab ) );
5194 std::map<OUString, ScRangeName*> aOldRangeMap;
5196 rDocShell.GetUndoManager()->AddUndoAction(
5197 std::make_unique<ScUndoAllRangeNames>(&rDocShell, aOldRangeMap, rRangeMap));
5211 bool& rCancel,
bool bApi )
5222 if (aName.isEmpty())
5225 OUString aContent(
ScRange( nX1, nY1, nTab, nX2, nY2, nTab ).
Format(
5228 bool bInsert =
false;
5233 if (aOldStr != aContent)
5239 OUString aTemplate =
ScResId( STR_CREATENAME_REPLACE );
5243 VclMessageType::Question, VclButtonsType::YesNo,
5246 xQueryBox->set_default_response(
RET_YES);
5248 short nResult = xQueryBox->run();
5266 if (!rList.
insert(pData))
5286 OSL_ENSURE(rRange.
aEnd.
Tab() == nTab,
"CreateNames: multiple tables not possible");
5290 if ( nStartRow == nEndRow )
5293 if ( nStartCol == nEndCol )
5314 SCCOL nContX1 = nStartCol;
5315 SCROW nContY1 = nStartRow;
5316 SCCOL nContX2 = nEndCol;
5317 SCROW nContY2 = nEndRow;
5328 bool bCancel =
false;
5333 for (i=nContX1; i<=nContX2; i++)
5334 CreateOneName( aNewRanges, i,nStartRow,nTab, i,nContY1,i,nContY2, bCancel, bApi );
5336 for (j=nContY1; j<=nContY2; j++)
5337 CreateOneName( aNewRanges, nStartCol,j,nTab, nContX1,j,nContX2,j, bCancel, bApi );
5339 for (i=nContX1; i<=nContX2; i++)
5340 CreateOneName( aNewRanges, i,nEndRow,nTab, i,nContY1,i,nContY2, bCancel, bApi );
5342 for (j=nContY1; j<=nContY2; j++)
5343 CreateOneName( aNewRanges, nEndCol,j,nTab, nContX1,j,nContX2,j, bCancel, bApi );
5345 if ( bTop && bLeft )
5346 CreateOneName( aNewRanges, nStartCol,nStartRow,nTab, nContX1,nContY1,nContX2,nContY2, bCancel, bApi );
5347 if ( bTop && bRight )
5348 CreateOneName( aNewRanges, nEndCol,nStartRow,nTab, nContX1,nContY1,nContX2,nContY2, bCancel, bApi );
5349 if ( bBottom && bLeft )
5350 CreateOneName( aNewRanges, nStartCol,nEndRow,nTab, nContX1,nContY1,nContX2,nContY2, bCancel, bApi );
5351 if ( bBottom && bRight )
5352 CreateOneName( aNewRanges, nEndCol,nEndRow,nTab, nContX1,nContY1,nContX2,nContY2, bCancel, bApi );
5354 ModifyRangeNames( aNewRanges, aTab );
5373 sal_uInt16 nValidCount = 0;
5374 for (
const auto& rEntry : *pLocalList)
5381 for (
const auto& rEntry : *pList)
5392 SCCOL nEndCol = nStartCol + 1;
5393 SCROW nEndRow = nStartRow +
static_cast<SCROW>(nValidCount) - 1;
5395 ScEditableTester aTester( rDoc, nTab, nStartCol,nStartRow, nEndCol,nEndRow );
5396 if (aTester.IsEditable())
5403 pUndoDoc->InitUndo( rDoc, nTab, nTab );
5404 rDoc.
CopyToDocument(nStartCol,nStartRow,nTab, nEndCol,nEndRow,nTab,
5410 std::unique_ptr<ScRangeData*[]> ppSortArray(
new ScRangeData* [ nValidCount ]);
5412 for (
const auto& rEntry : *pLocalList)
5416 ppSortArray[j++] = &r;
5418 for (
const auto& [rName, rxData] : *pList)
5422 ppSortArray[j++] = &r;
5424 qsort( static_cast<void*>(ppSortArray.get()), nValidCount,
sizeof(
ScRangeData*),
5427 OUStringBuffer aContent;
5429 SCROW nOutRow = nStartRow;
5430 for (j=0; j<nValidCount; j++)
5436 aFormula =
"=" + aContent;
5444 ppSortArray.reset();
5449 pRedoDoc->InitUndo( rDoc, nTab, nTab );
5450 rDoc.
CopyToDocument(nStartCol,nStartRow,nTab, nEndCol,nEndRow,nTab,
5453 rDocShell.GetUndoManager()->AddUndoAction(
5454 std::make_unique<ScUndoListNames>( &rDocShell,
5455 ScRange( nStartCol,nStartRow,nTab, nEndCol,nEndRow,nTab ),
5456 std::move(pUndoDoc), std::move(pRedoDoc) ) );
5459 if (!AdjustRowHeight(
ScRange(0,nStartRow,nTab,rDoc.
MaxCol(),nEndRow,nTab),
true,
true))
5466 rDocShell.ErrorMessage(aTester.GetMessageId());
5478 OUString aFormula = rDoc.
GetFormula( nStartCol, nStartRow, nTab );
5479 if ( !(aFormula.startsWith(
"{") && aFormula.endsWith(
"}")) )
5482 OUString aUndo =
ScResId( STR_UNDO_RESIZEMATRIX );
5488 nViewShellId = pViewSh->GetViewShellId();
5489 rDocShell.GetUndoManager()->EnterListAction( aUndo, aUndo, 0, nViewShellId );
5492 aFormula = aFormula.copy(1, aFormula.getLength()-2);
5496 aMark.SelectTable( nTab,
true );
5510 rDocShell.GetUndoManager()->LeaveListAction();
5514 const OUString& rOptions,
const OUString& rSource,
5515 const ScRange& rDestRange, sal_Int32 nRefreshDelaySeconds,
5516 bool bFitBlock,
bool bApi )
5527 sal_uInt16 nLinkCount = pLinkManager->
GetLinks().size();
5528 sal_uInt16 nRemoved = 0;
5529 sal_uInt16 nLinkPos = 0;
5530 while (nLinkPos<nLinkCount)
5541 OUString aUndo =
ScResId( STR_UNDO_INSERTAREALINK );