36#include <osl/diagnose.h>
38#include <com/sun/star/text/WritingMode2.hpp>
39#include <com/sun/star/script/vba/XVBACompatibility.hpp>
40#include <com/sun/star/sheet/TablePageBreakData.hpp>
41#include <com/sun/star/lang/NotInitializedException.hpp>
43#include <document.hxx>
55#include <stlsheet.hxx>
72#include <progress.hxx>
92#include <undomanager.hxx>
109using ::editeng::SvxBorderLine;
112namespace WritingMode2 = ::com::sun::star::text::WritingMode2;
113using ::com::sun::star::uno::Sequence;
114using ::com::sun::star::sheet::TablePageBreakData;
119std::pair<SCTAB,SCTAB> getMarkedTableRange(
const std::vector<ScTableUniquePtr>& rTables,
const ScMarkData& rMark)
123 SCTAB nMax =
static_cast<SCTAB>(rTables.size());
124 for (
const auto& rTab : rMark)
132 if (rTab < nTabStart)
137 return std::pair<SCTAB,SCTAB>(nTabStart,nTabEnd);
140void collectUIInformation(std::map<OUString, OUString>&& aParameters,
const OUString& rAction)
143 aDescription.
aID =
"grid_window";
144 aDescription.
aAction = rAction;
146 aDescription.
aParent =
"MainWindow";
147 aDescription.
aKeyWord =
"ScGridWinUIObject";
157 explicit ScDefaultAttr(
const ScPatternAttr* pPatAttr) : pAttr(pPatAttr), nFirst(0),
nCount(0) {}
160struct ScLessDefaultAttr
162 bool operator() (
const ScDefaultAttr& rValue1,
const ScDefaultAttr& rValue2)
const
164 return rValue1.pAttr < rValue2.pAttr;
180 if ( _bNeedsNameCheck )
189 maTabs.push_back(
nullptr);
210 rHashCode =
maTabs[nTab]->GetHashCode();
223 rName =
maTabs[nTab]->GetName();
244 maTabs[nTab]->SetCodeName( rName );
248 SAL_WARN(
"sc",
"can't set code name " << rName );
257 rName =
maTabs[nTab]->GetCodeName();
266 static OUString aCacheName, aCacheUpperName;
269 if (aCacheName != rName)
275 const OUString aUpperName = aCacheUpperName;
280 if (aUpperName ==
maTabs[
i]->GetUpperName())
292 std::vector<OUString> aNames;
293 aNames.reserve(
maTabs.size());
304 aNames.push_back(
aName);
313 return maTabs[nTab]->GetAnonymousDBData();
325 maTabs[nTab]->SetAnonymousDBData(std::move(pDBData));
342 sal_Int32 nLen = rName.getLength();
350 for (sal_Int32
i = 0;
i < nLen; ++
i)
365 if (
i == 0 ||
i == nLen - 1)
387 const OUString& rOldName =
a->GetUpperName();
388 bValid = rOldName != aUpperName;
409 OSL_ENSURE(bPrefix,
"Invalid Table Name");
414 rName = aStrTable + OUString::number(
static_cast<sal_Int32
>(
i));
428 OUStringBuffer
aName;
434 aName.append(
static_cast<sal_Int32
>(
i));
437 rName =
aName.makeStringAndClear();
450 OUStringBuffer rName;
454 OSL_ENSURE(bPrefix,
"Invalid Table Name");
464 rName.append(
static_cast<sal_Int32
>(
i));
468 bOk = !
GetTable( rName.toString(), nDummy );
471 aNames.push_back(rName.makeStringAndClear());
482 OUString
aName = rName;
495 maTabs[nTab]->SetName(rName);
503 a->SetStreamValid(
false);
508 SCTAB nPos,
const OUString& rName,
bool bExternalDocument,
bool bUndoDeleteTab )
512 if ( !bExternalDocument )
520 if ( bExternalDocument )
521 maTabs[nTabCount]->SetVisible(
false );
548 a->UpdateInsertTab(aCxt);
598 SCTAB nNewSheets =
static_cast<SCTAB>(rNames.size());
600 bool bValid = bNamesValid ||
ValidTab(nTabCount+nNewSheets);
606 for (
SCTAB i = 0;
i < nNewSheets; ++
i )
608 maTabs.emplace_back(
new ScTable(*
this, nTabCount +
i, rNames.at(
i)) );
635 a->UpdateInsertTab(aCxt);
637 for (
SCTAB i = 0;
i < nNewSheets; ++
i)
728 for (
auto & pTab :
maTabs)
730 pTab->UpdateDeleteTab(aCxt);
738 delete pErasedTab.release();
780 if (nTabCount > nSheets)
786 for (
SCTAB aTab = 0; aTab < nSheets; ++aTab)
828 for (
auto & pTab :
maTabs)
830 pTab->UpdateDeleteTab(aCxt);
873 if ( bExternalDocument )
877 for (
i=0; (i< static_cast<SCTAB>(
maTabs.size())) && bValid;
i++)
880 OUString aOldName =
maTabs[
i]->GetName();
889 maTabs[nTab]->SetName(rName);
896 a->SetStreamValid(
false );
908 collectUIInformation({{
"NewName", rName}},
"Rename_Sheet");
924 return maTabs[nTab]->IsVisible();
932 return maTabs[nTab]->IsStreamValid();
940 maTabs[nTab]->SetStreamValid( bSet, bIgnoreLock );
951 return maTabs[nTab]->IsPendingRowHeights();
959 maTabs[nTab]->SetPendingRowHeights( bSet );
973 maTabs[nTab]->SetLoadingRTL( bRTL );
977 maTabs[nTab]->SetLayoutRTL( bRTL );
978 maTabs[nTab]->SetDrawPageSize(
true,
true, eObjectHandling);
985 OSL_ENSURE(pPage,
"Page ?");
993 pObject->SetContextWritingMode( bRTL ? WritingMode2::RL_TB : WritingMode2::LR_TB );
1001 return maTabs[nTab]->IsLayoutRTL();
1026 return maTabs[nTab]->GetCellArea( rEndCol, rEndRow );
1037 return maTabs[nTab]->GetTableArea( rEndCol, rEndRow, bCalcHiddens);
1051 maTabs[nTab]->GetFirstDataPos(nCol1, nRow1);
1052 maTabs[nTab]->GetLastDataPos(nCol2, nRow2);
1054 if (nCol1 > nCol2 || nRow1 > nRow2)
1059 if (rStartCol < nCol1)
1061 if (nCol2 < rEndCol)
1063 if (rStartRow < nRow1)
1065 if (nRow2 < rEndRow)
1068 if (rStartCol > rEndCol || rStartRow > rEndRow)
1077 bool bStickyTopRow,
bool bStickyLeftCol,
ScDataAreaExtras* pDataAreaExtras )
const
1084 return maTabs[nTab]->ShrinkToUsedDataArea(
1085 o_bShrunk, rStartCol, rStartRow, rEndCol, rEndRow, bColumnsOnly, bStickyTopRow,
1086 bStickyLeftCol, pDataAreaExtras);
1101 SCCOL& rEndCol,
SCROW& rEndRow,
bool bIncludeOld,
bool bOnlyDown )
const
1104 maTabs[nTab]->GetDataArea( rStartCol, rStartRow, rEndCol, rEndRow, bIncludeOld, bOnlyDown );
1110 if (nTab != rRange.
aEnd.
Tab())
1114 return maTabs[nTab]->GetDataAreaSubrange(rRange);
1124 maTabs[nTab]->LimitChartArea( rStartCol, rStartRow, rEndCol, rEndRow );
1130 if (rRangeList.
is())
1134 ScRange aRange( (*rRangeList)[
i] );
1144 maTabs[nTab]->LimitChartArea(nStartCol, nStartRow, nEndCol, nEndRow);
1150 aNew->push_back(aRange);
1155 OSL_FAIL(
"LimitChartIfAll: Ref==0");
1166 for (
SCTAB nTab=0; nTab< aMaxTab; ++nTab)
1173 rTabRangeEnd = nTab;
1183 for (
SCTAB nTab=rTabRangeEnd+1; nTab< aMaxTab; ++nTab)
1186 rTabRangeStart = nTab;
1189 rTabRangeEnd = nTab;
1207 SCSIZE nSize =
static_cast<SCSIZE>(nEndRow - nStartRow + 1);
1210 for (
SCTAB i=nStartTab; i<=nEndTab && bTest && i < static_cast<SCTAB>(
maTabs.size());
i++)
1212 bTest &=
maTabs[
i]->TestInsertRow( nStartCol, nEndCol, nStartRow, nSize );
1219struct SetDirtyIfPostponedHandler
1224 p->SetDirtyIfPostponed();
1228struct BroadcastRecalcOnRefMoveHandler
1233 p->BroadcastRecalcOnRefMove();
1237struct BroadcastRecalcOnRefMoveGuard
1239 explicit BroadcastRecalcOnRefMoveGuard(
ScDocument* pDoc ) :
1240 aSwitch( *pDoc, false),
1273 for (
i = nStartTab; i <= nEndTab && bTest && i < static_cast<SCTAB>(
maTabs.size());
i++)
1275 bTest &=
maTabs[
i]->TestInsertRow(nStartCol, nEndCol, nStartRow, nSize);
1282 SCTAB nTabRangeStart = nStartTab;
1283 SCTAB nTabRangeEnd = nEndTab;
1285 ScRange aShiftedRange(nStartCol, nStartRow, nTabRangeStart, nEndCol,
MaxRow(), nTabRangeEnd);
1288 std::vector<ScAddress> aGroupPos;
1323 for (
i=nStartTab; i<=nEndTab && i < static_cast<SCTAB>(
maTabs.size());
i++)
1329 for (
i=nStartTab; i<=nEndTab && i < static_cast<SCTAB>(
maTabs.size());
i++)
1332 nStartCol, nStartRow, nStartTab, nEndCol,
MaxRow(), nEndTab,
1333 0,
static_cast<SCROW>(nSize), 0 );
1350 a->SetDirtyIfPostponed();
1354 BroadcastRecalcOnRefMoveGuard g(
this);
1355 std::for_each(
maTabs.begin(),
maTabs.end(), BroadcastRecalcOnRefMoveHandler());
1393 SCTAB nTabRangeStart = nStartTab;
1394 SCTAB nTabRangeEnd = nEndTab;
1401 ScAddress( nStartCol, nStartRow, nTabRangeStart ),
1402 ScAddress( nEndCol, nStartRow+nSize-1, nTabRangeEnd ) ) );
1404 ScAddress( nStartCol, nStartRow+nSize, nTabRangeStart ),
1409 ScAddress( nStartCol, nStartRow, nTabRangeStart ),
1416 if (
ValidRow(nStartRow+nSize) || bLastRowIncluded )
1421 if (bLastRowIncluded)
1428 aCxt.
maRange =
ScRange( nStartCol, nStartRow+nSize, nTabRangeStart, nEndCol,
MaxRow(), nTabRangeEnd);
1438 *pUndoOutline =
false;
1442 std::vector<ScAddress> aGroupPos;
1444 for (
i = nStartTab; i <= nEndTab && i < static_cast<SCTAB>(
maTabs.size());
i++)
1455 if (
ValidRow(nStartRow+nSize) || bLastRowIncluded )
1465 a->SetDirtyIfPostponed();
1469 BroadcastRecalcOnRefMoveGuard g(
this);
1470 std::for_each(
maTabs.begin(),
maTabs.end(), BroadcastRecalcOnRefMoveHandler());
1496 SCSIZE nSize =
static_cast<SCSIZE>(nEndCol - nStartCol + 1);
1499 for (
SCTAB i=nStartTab; i<=nEndTab && bTest && i < static_cast<SCTAB>(
maTabs.size());
i++)
1501 bTest &=
maTabs[
i]->TestInsertCol( nStartRow, nEndRow, nSize );
1527 for (
i = nStartTab; i <= nEndTab && bTest && i < static_cast<SCTAB>(
maTabs.size());
i++)
1529 bTest &=
maTabs[
i]->TestInsertCol( nStartRow, nEndRow, nSize );
1533 SCTAB nTabRangeStart = nStartTab;
1534 SCTAB nTabRangeEnd = nEndTab;
1539 ScAddress( nStartCol, nStartRow, nTabRangeStart ),
1556 for (
i=nStartTab; i<=nEndTab && i < static_cast<SCTAB>(
maTabs.size());
i++)
1574 std::for_each(
maTabs.begin(),
maTabs.end(), SetDirtyIfPostponedHandler());
1579 BroadcastRecalcOnRefMoveGuard g(
this);
1580 std::for_each(
maTabs.begin(),
maTabs.end(), BroadcastRecalcOnRefMoveHandler());
1601 bool* pUndoOutline,
const ScMarkData* pTabMark )
1617 SCTAB nTabRangeStart = nStartTab;
1618 SCTAB nTabRangeEnd = nEndTab;
1622 if (
ValidCol(sal::static_int_cast<SCCOL>(nStartCol+nSize)) )
1625 ScAddress( nStartCol, nStartRow, nTabRangeStart ),
1626 ScAddress( sal::static_int_cast<SCCOL>(nStartCol+nSize-1), nEndRow, nTabRangeEnd ) ) );
1628 ScAddress( sal::static_int_cast<SCCOL>(nStartCol+nSize), nStartRow, nTabRangeStart ),
1633 ScAddress( nStartCol, nStartRow, nTabRangeStart ),
1640 if (
ValidCol(sal::static_int_cast<SCCOL>(nStartCol+nSize)) || bLastColIncluded )
1645 if (bLastColIncluded)
1652 aCxt.
maRange =
ScRange( sal::static_int_cast<SCCOL>(nStartCol+nSize), nStartRow, nTabRangeStart,
1653 MaxCol(), nEndRow, nTabRangeEnd);
1663 *pUndoOutline =
false;
1665 for (
i = nStartTab; i <= nEndTab && i < static_cast<SCTAB>(
maTabs.size()); ++
i)
1671 if (
ValidCol(sal::static_int_cast<SCCOL>(nStartCol+nSize)) || bLastColIncluded )
1681 a->SetDirtyIfPostponed();
1685 BroadcastRecalcOnRefMoveGuard g(
this);
1686 std::for_each(
maTabs.begin(),
maTabs.end(), BroadcastRecalcOnRefMoveHandler());
1705 ScRange& rColRange,
bool& rInsCol,
bool& rDelCol,
1706 ScRange& rRowRange,
bool& rInsRow,
bool& rDelRow )
1708 OSL_ENSURE( rOld.
aStart == rNew.
aStart,
"FitBlock: Beginning is different" );
1710 rInsCol = rDelCol = rInsRow = rDelRow =
false;
1721 bool bGrowY = ( nNewEndY > nOldEndY );
1722 SCROW nColEndY = bGrowY ? nOldEndY : nNewEndY;
1723 SCCOL nRowEndX = bGrowY ? nNewEndX : nOldEndX;
1727 if ( nNewEndX > nOldEndX )
1729 rColRange =
ScRange( nOldEndX+1, nStartY, nTab, nNewEndX, nColEndY, nTab );
1732 else if ( nNewEndX < nOldEndX )
1734 rColRange =
ScRange( nNewEndX+1, nStartY, nTab, nOldEndX, nColEndY, nTab );
1740 if ( nNewEndY > nOldEndY )
1742 rRowRange =
ScRange( nStartX, nOldEndY+1, nTab, nRowEndX, nNewEndY, nTab );
1745 else if ( nNewEndY < nOldEndY )
1747 rRowRange =
ScRange( nStartX, nNewEndY+1, nTab, nRowEndX, nOldEndY, nTab );
1762 if (
HasAttrib( nStartX, nStartY, nTab, nEndX, nEndY, nTab,
1765 ExtendMerge( nStartX, nStartY, nEndX, nEndY, nTab );
1780 return maTabs[nTab]->ResolveStaticReference(rPos.
Col(), rPos.
Row());
1789 return maTabs[nTab]->ResolveStaticReference(
1824 return maTabs[nTab]->HandleRefArrayForParallelism(rPos.
Col(), rPos.
Row(), rPos.
Row()+
nLength-1, mxGroup);
1833 bool bInsCol,bDelCol,bInsRow,bDelRow;
1842 if ( bInsCol || bDelCol )
1848 if ( bInsRow || bDelRow )
1863 bool bInsCol,bDelCol,bInsRow,bDelRow;
1879 if ( bInsCol || bInsRow )
1899 std::vector<ScAddress> aGroupPos;
1907 ScRange aRange(nCol1, nRow1, 0, nCol2, nRow2, 0);
1908 for (
SCTAB i = 0; i < static_cast<SCTAB>(
maTabs.size());
i++)
1921 for (
SCTAB i = 0; i < static_cast<SCTAB>(
maTabs.size());
i++)
1924 maTabs[
i]->
DeleteArea(nCol1, nRow1, nCol2, nRow2, nDelFlag, bBroadcast, pBroadcastSpans);
1936 if (aGroupPos.empty())
1939 ScRange aRange(nCol1, nRow1, 0, nCol2, nRow2, 0);
1940 for (
SCTAB i = 0; i < static_cast<SCTAB>(
maTabs.size());
i++)
1961 maTabs[nTab]->DeleteArea(nCol1, nRow1, nCol2, nRow2, nDelFlag);
1975 bool bColInfo,
bool bRowInfo )
1988 maTabs[nTab] = std::move(pTable);
1990 maTabs.push_back(std::move(pTable));
1997 maTabs.push_back(
nullptr);
2002 OSL_FAIL(
"InitUndo");
2007 bool bColInfo,
bool bRowInfo )
2011 OSL_FAIL(
"InitUndo");
2024 maTabs.resize(nTab2 + 1);
2025 for (
SCTAB nTab = nTab1; nTab <= nTab2; nTab++)
2027 maTabs[nTab].reset(
new ScTable(*
this, nTab, OUString(), bColInfo, bRowInfo));
2035 OSL_FAIL(
"AddUndoTab");
2044 for (
SCTAB nTab = nTab1; nTab <= nTab2; nTab++)
2047 maTabs[nTab].reset(
new ScTable(*
this, nTab, OUString(), bColInfo, bRowInfo) );
2057 OSL_FAIL(
"SetCutMode without bIsClip");
2067 OSL_FAIL(
"IsCutMode without bIsClip");
2075 const ScMarkData* pMarks,
bool bColRowFlags )
2079 ScRange aThisRange(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
2080 CopyToDocument(aThisRange, nFlags, bOnlyMarked, rDestDoc, pMarks, bColRowFlags);
2100 assert( nTab2 <
static_cast<SCTAB>(
maTabs.size()) && nTab2 <
static_cast<SCTAB>(rDestDoc.
maTabs.size()));
2101 for (
SCTAB i = nTab1;
i <= nTab2;
i++)
2104 maTabs[
i]->UndoToTable(aCxt, nCol1, nRow1, nCol2, nRow2, nFlags,
2105 bOnlyMarked, rDestDoc.
maTabs[
i].get());
2134 if (!pTab || !pDestTab)
2139 nFlags, bOnlyMarked, pDestTab, pMarks,
false, bColRowFlags,
2161 for (
SCTAB i = nTab1;
i <= nTab2 &&
i < nMinSizeBothTabs;
i++)
2166 nFlags, bOnlyMarked, rDestDoc.
maTabs[
i].get());
2175 bool bKeepScenarioFlags,
bool bIncludeObjects )
2177 OSL_ENSURE( pMarks,
"CopyToClip: ScMarkData fails" );
2184 SAL_WARN(
"sc",
"CopyToClip: no ClipDoc");
2201 for (
const auto& rxTab :
maTabs)
2205 OUString aTabName = rxTab->GetName();
2222 for (
SCTAB i = 0;
i < nEndTab; ++
i)
2248 ScTable* pDestTab = nDestTab < static_cast<SCTAB>(rDestDoc.
maTabs.size()) ? rDestDoc.
maTabs[nDestTab].get() :
nullptr;
2250 if (!pSrcTab || !pDestTab)
2281 SAL_WARN(
"sc",
"CopyTabToClip: no ClipDoc");
2298 for (
const auto& rxTab :
maTabs)
2302 OUString aTabName = rxTab->GetName();
2321 maTabs[nTab]->CopyToClip(aCxt, nCol1, nRow1, nCol2, nRow2, pClipDoc->
maTabs[nTab].get());
2327 bool bIncludeFiltered)
2330 "TransposeClip with wrong Document" );
2344 sal_uInt16
nIndex = rEntry.second->GetIndex();
2355 SAL_WARN(
"sc",
"TransposeClip: Too big");
2365 const bool bIsMultiRangeRowFilteredTranspose
2372 if (bIsMultiRangeRowFilteredTranspose)
2379 SCROW nRowCount = 0;
2380 for (
size_t j = 0,
n = aClipRanges.
size(); j <
n; ++j)
2382 aClipRange = aClipRanges[j];
2384 SCROW nRowOffset = 0;
2385 if (bIsMultiRangeRowFilteredTranspose)
2388 nRowOffset = nRowCount;
2393 assert(!bIncludeFiltered &&
"bIsMultiRangeRowFilteredTranspose can only be true if bIncludeFiltered is false");
2394 nRowCount += nRowCountNonFiltered;
2397 for (
SCTAB i = 0; i < static_cast<SCTAB>(
maTabs.size());
i++)
2401 OSL_ENSURE(pTransClip->
maTabs[
i],
"TransposeClip: Table not there");
2405 pTransClip->
maTabs[
i].get(), nFlags, bAsLink, bIncludeFiltered);
2429 bIsMultiRangeRowFilteredTranspose);
2441 pClipRangeName->
clear();
2442 for (
const auto& rEntry : *pRangeName)
2444 sal_uInt16
nIndex = rEntry.second->GetIndex();
2445 bool bInUse = (rUsedNames.count(nIndex) > 0);
2450 if (pClipRangeName->
insert(pData))
2451 pData->SetIndex(nIndex);
2464 for (
SCTAB i = 0;
i < nMinSizeBothTabs; ++
i)
2467 maTabs[
i]->FindRangeNamesInUse(
2485 mrDoc.pFormatExchangeList =
nullptr;
2521#if DUMP_COLUMN_STORAGE
2532#if DEBUG_AREA_BROADCASTER
2533void ScDocument::DumpAreaBroadcasters()
const
2550 return maTabs[nTab].get();
2558 return maTabs[nTab].get();
2565 SAL_WARN(
"sc",
"GetWritableColumnsRange() called for non-existent table");
2568 return maTabs[nTab]->GetWritableColumnsRange(nColBegin, nColEnd);
2575 return maTabs[nTab]->GetAllocatedColumnsRange(nColBegin, nColEnd);
2582 return maTabs[nTab]->GetColumnsRange(nColBegin, nColEnd);
2589 if (pOtherFormatter && pOtherFormatter != pThisFormatter)
2593 if (!pExchangeList->empty())
2631 auto pSet = std::make_shared<sc::ColumnBlockPositionSet>(*
this);
2637 for (
const auto& rTab : rMark)
2642 maTabs[rTab]->StartListeningFormulaCells(aStartCxt, aEndCxt, nCol1, nRow1, nCol2, nRow2);
2653 for (
const auto& rTab : rMark)
2658 maTabs[rTab]->SetDirtyFromClip(nCol1, nRow1, nCol2, nRow2, rBroadcastSpans);
2668 return maTabs[nTab]->InitColumnBlockPosition(rBlockPos, nCol);
2682 while (!rClipTabs[nClipTab]) nClipTab = (nClipTab+1) %
static_cast<SCTAB>(rClipTabs.size());
2685 rCxt, nCol1, nRow1, nCol2, nRow2, nDx, nDy, rClipTabs[nClipTab].
get());
2693 OSL_ENSURE(
mpDrawLayer,
"CopyBlockFromClip: No drawing layer" );
2701 nCol1-nDx, nRow1-nDy, nCol2-nDx, nRow2-nDy, nClipTab );
2708 nClipTab = (nClipTab+1) %
static_cast<SCTAB>(rClipTabs.size());
2719 while (!rClipTabs[nClipTab]) nClipTab = (nClipTab+1) %
static_cast<SCTAB>(rClipTabs.size());
2720 SCTAB nDz =
i - nClipTab;
2725 while (
i + nFollow < nTabEnd
2727 && nClipTab + nFollow <
MAXTAB
2728 && rClipTabs[(nClipTab + nFollow + 1) %
static_cast<SCTAB>(rClipTabs.size())] )
2755 auto pColSet = std::make_shared<sc::ColumnSet>( aRefCxt.
maRegroupCols);
2768 nClipTab = (nClipTab+nFollow+1) %
static_cast<SCTAB>(rClipTabs.size());
2769 i = sal::static_int_cast<SCTAB>(
i + nFollow );
2784 while ( nFlagTab <
static_cast<SCTAB>(rClipTabs.size()) && !rClipTabs[nFlagTab] )
2787 SCROW nSourceRow = rClipStartRow;
2788 SCROW nSourceEnd = nClipEndRow;
2789 SCROW nDestRow = nRow1;
2790 SCROW nFilteredRows = 0;
2792 while ( nSourceRow <= nSourceEnd && nDestRow <= nRow2 )
2795 SCROW nSourceRowOriginal = nSourceRow;
2797 nFilteredRows += nSourceRow - nSourceRowOriginal;
2799 if ( nSourceRow <= nSourceEnd )
2802 SCROW nLastRow = nSourceRow;
2804 SCROW nFollow = nLastRow - nSourceRow;
2806 if (nFollow > nSourceEnd - nSourceRow)
2807 nFollow = nSourceEnd - nSourceRow;
2808 if (nFollow > nRow2 - nDestRow)
2809 nFollow = nRow2 - nDestRow;
2811 SCROW nNewDy = nDestRow - nSourceRow;
2813 rCxt, nCol1, nDestRow, nCol2, nDestRow + nFollow, rMark, nDx, nNewDy);
2815 nSourceRow += nFollow + 1;
2816 nDestRow += nFollow + 1;
2819 rClipStartRow = nSourceRow;
2820 return nFilteredRows;
2831 explicit BroadcastAction(
ScDocument& rDoc ) : mrDoc(rDoc), mpCol(nullptr) {}
2833 virtual void startColumn(
ScColumn* pCol )
override
2838 virtual void execute(
SCROW nRow1,
SCROW nRow2,
bool bVal )
override
2845 aRange.aEnd.SetRow(nRow2);
2855 bool bAsLink,
bool bIncludeFiltered,
bool bSkipEmptyCells,
2863 OSL_FAIL(
"CopyFromClip: no ClipDoc");
2882 for (
SCTAB nTab = 0; nTab < static_cast<SCTAB>(pClipDoc->
maTabs.size()); nTab++)
2883 if (pClipDoc->
maTabs[nTab])
2889 nThisEndX, nThisEndY, nTab );
2891 nThisEndX = sal::static_int_cast<SCCOL>( nThisEndX - aClipRange.
aEnd.
Col() );
2892 nThisEndY = sal::static_int_cast<SCROW>( nThisEndY - aClipRange.
aEnd.
Row() );
2893 if ( nThisEndX > nXw )
2895 if ( nThisEndY > nYw )
2901 pClipDoc->
GetClipArea( nDestAddX, nDestAddY, bIncludeFiltered );
2902 nXw = sal::static_int_cast<SCCOL>( nXw + nDestAddX );
2903 nYw = sal::static_int_cast<SCROW>( nYw + nDestAddY );
2922 std::pair<SCTAB,SCTAB> aTabRanges = getMarkedTableRange(
maTabs, rMark);
2923 aCxt.
setTabRange(aTabRanges.first, aTabRanges.second);
2930 pDestRanges = &aLocalRangeList;
2940 for (
size_t nRange = 0; nRange < pDestRanges->
size(); ++nRange )
2942 const ScRange & rRange = (*pDestRanges)[nRange];
2956 SCCOL nC2 = nC1 + nXw;
2959 SCROW nR2 = nR1 + nYw;
2965 std::vector< SCTAB > vTables;
2967 if (bPreallocatePattern)
2971 vTables.push_back(
i );
2981 SCROW nSaveClipStartRow = nClipStartRow;
2984 nClipStartRow = nSaveClipStartRow;
2985 SCCOL nDx = nC1 - nClipStartCol;
2986 SCROW nDy = nR1 - nClipStartRow;
2987 if ( bIncludeFiltered )
2990 aCxt, nC1, nR1, nC2, nR2, rMark, nDx, nDy);
2991 nClipStartRow += nR2 - nR1 + 1;
2999 nC2 = std::min(
static_cast<SCCOL>(nC1 + nXw), nCol2);
3000 }
while (nC1 <= nCol2);
3001 if (nClipStartRow > nClipEndRow)
3002 nClipStartRow = aClipRange.
aStart.
Row();
3009 if (bPreallocatePattern && (nR2+1) <= nRow2)
3011 SCROW nR3 = nR2 + 1;
3012 for (
SCTAB nTab : vTables)
3014 for (
SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
3025 SCSIZE nNeeded = nChunk * (nRow2 - nR3 + 1) / (nYw + 1);
3027 if (nNeeded > nRemain)
3035 bPreallocatePattern =
false;
3039 nR2 = std::min(
static_cast<SCROW>(nR1 + nYw), nRow2);
3040 }
while (nR1 <= nRow2);
3053 SetDirtyFromClip(nAllCol1, nAllRow1, nAllCol2, nAllRow2, rMark, nInsFlag, aBroadcastSpans);
3055 BroadcastAction aAction(*
this);
3065 bool bResetCut,
bool bAsLink,
bool bIncludeFiltered,
3066 bool bSkipAttrForEmpty)
3090 if (!bSkipAttrForEmpty)
3100 std::pair<SCTAB,SCTAB> aTabRanges = getMarkedTableRange(
maTabs, rMark);
3101 aCxt.
setTabRange(aTabRanges.first, aTabRanges.second);
3111 SCROW nEndRow = nRow1 + nRowCount - 1;
3112 SCROW nFilteredRows = 0;
3114 if (bIncludeFiltered)
3123 nClipStartRow, nClipEndRow);
3124 nRowCount -= nFilteredRows;
3153 rMark, nInsFlag, aBroadcastSpans);
3155 BroadcastAction aAction(*
this);
3174 OSL_FAIL(
"SetClipArea: No Clip");
3182 OSL_FAIL(
"GetClipArea: No Clip");
3187 if (rClipRanges.
empty())
3196 for (
size_t i = 1,
n = rClipRanges.
size();
i <
n; ++
i )
3198 ScRange const & rRange2 = rClipRanges[
i ];
3203 if (rRange2.
aEnd.
Col() > nEndCol)
3205 if (rRange2.
aEnd.
Row() > nEndRow)
3209 nClipX = nEndCol - nStartCol;
3211 if ( bIncludeFiltered )
3212 nClipY = nEndRow - nStartRow;
3217 SCTAB nCountTab = 0;
3224 nClipY = nResult - 1;
3235 if ( !rClipRanges.
empty() )
3243 OSL_FAIL(
"GetClipStart: No Clip");
3250 SCTAB nCountTab = 0;
3255 if ( rClipRanges.
empty() )
3258 for (
size_t i = 0,
n = rClipRanges.
size();
i <
n; ++
i )
3260 ScRange & rRange = rClipRanges[
i ];
3275 for (
SCTAB i = nTab1;
i <= nTab2 &&
i < nMinSizeBothTabs;
i++)
3279 if (!pTab || !pSrcTab)
3284 nFunction, bSkipEmpty, pSrcTab);
3290 bool bSkipEmpty,
bool bAsLink )
3314 for (
const SCTAB&
i : rMark)
3325 pMixDoc->InitUndo( *
this,
i,
i );
3328 pMixDoc->AddUndoTab(
i,
i );
3332 maTabs[
i]->CopyToTable(aMixCxt, nStartCol,nStartRow, nEndCol,nEndRow,
3334 nullptr,
false,
true,
3337 maTabs[
i]->DeleteArea( nStartCol,nStartRow, nEndCol,nEndRow, nDelFlags);
3338 maTabs[nSrcTab]->CopyToTable(aCxt, nStartCol,nStartRow, nEndCol,nEndRow,
3339 nFlags,
false,
maTabs[
i].
get(),
nullptr, bAsLink,
3340 true,
false,
true );
3343 maTabs[
i]->MixData(aMixDocCxt, nStartCol,nStartRow, nEndCol,nEndRow,
3344 nFunction, bSkipEmpty, pMixDoc->maTabs[
i].get() );
3352 OSL_FAIL(
"wrong table");
3358 bool bSkipEmpty,
bool bAsLink )
3381 for (
const SCTAB&
i : rMark)
3392 pMixDoc->InitUndo( *
this,
i,
i );
3395 pMixDoc->AddUndoTab(
i,
i );
3398 maTabs[
i]->CopyToTable(aMixCxt, nStartCol,nStartRow, nEndCol,nEndRow,
3404 maTabs[
i]->DeleteSelection( nDelFlags, rMark );
3405 maTabs[nSrcTab]->CopyToTable(aCxt, nStartCol,nStartRow, nEndCol,nEndRow,
3406 nFlags,
true,
maTabs[
i].
get(), &rMark, bAsLink,
3407 true,
false,
true );
3410 maTabs[
i]->MixMarked(aMixDocCxt, rMark, nFunction, bSkipEmpty, pMixDoc->maTabs[
i].get());
3418 OSL_FAIL(
"wrong table");
3430 if (pCurCellFormula && pCurCellFormula->
IsShared())
3444 return pTab->
SetString(nCol, nRow, nTab, rString, pParam);
3460 return maTabs[rPos.
Tab()]->SetEditText(rPos.
Col(), rPos.
Row(), std::move(pEditText));
3468 maTabs[rPos.
Tab()]->SetEditText(rPos.
Col(), rPos.
Row(), rEditText, pEditPool);
3529 if (pCurCellFormula && pCurCellFormula->
IsShared())
3548 return maTabs[nTab]->GetString(nCol, nRow, pContext);
3557 return maTabs[rPos.
Tab()]->GetString(rPos.
Col(), rPos.
Row(), pContext);
3595 return maTabs[nTab]->GetInputString( nCol, nRow, bForceSystemLocale );
3610 return FormulaError::NONE;
3630 SvNumFormatType::NUMBER,
3642 SvNumFormatType::NUMBER,
3661 return maTabs[nTab]->GetEditText(rPos.
Col(), rPos.
Row());
3669 return maTabs[rPos.
Tab()]->RemoveEditTextCharAttribs(rPos.
Col(), rPos.
Row(), rAttr);
3691 return maTabs[nTab]->GetNumberFormat( nCol, nRow );
3705 sal_uInt32 nFormat = 0;
3706 bool bFirstItem =
true;
3707 for (
SCTAB nTab = nTab1; nTab <= nTab2 && nTab < static_cast<SCTAB>(
maTabs.size()) ; ++nTab)
3708 for (
SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
3710 sal_uInt32 nThisFormat =
maTabs[nTab]->GetNumberFormat(nCol, nRow1, nRow2);
3713 nFormat = nThisFormat;
3716 else if (nThisFormat != nFormat)
3729 return maTabs[nTab]->GetNumberFormat( rContext, rPos );
3739 maTabs[nTab]->SetNumberFormat(rPos.
Col(), rPos.
Row(), nNumberFormat);
3748 nIndex =
maTabs[nTab]->GetNumberFormat( rContext, rPos );
3753 nType = SvNumFormatType::UNDEFINED;
3761 return maTabs[nTab]->GetFormula( nCol, nRow );
3786 return maTabs[nTab]->GetCellType( rPos );
3793 return maTabs[nTab]->GetCellType( nCol, nRow );
3801 && nCol <
maTabs[nTab]->GetAllocatedColumnsCount())
3802 return maTabs[nTab]->HasStringData( nCol, nRow );
3810 && nCol <
maTabs[nTab]->GetAllocatedColumnsCount())
3811 return maTabs[nTab]->HasValueData( nCol, nRow );
3832 for (
SCTAB nTab=nStartTab; nTab<=nEndTab && nTab < static_cast<SCTAB>(
maTabs.size()); nTab++ )
3871 a->CheckVectorizationState();
3886 a->SetAllFormulasDirty(rCxt);
3914 if (bIncludeEmptyCells)
3937 for (
size_t nPos=0, nRangeCount = rRanges.
size();
nPos < nRangeCount;
nPos++)
3957 bool allInterpreted =
true;
3958 for (
size_t nPos=0, nRangeCount = rRanges.
size();
nPos < nRangeCount;
nPos++)
3970 allInterpreted =
false;
3974 return allInterpreted;
3983 if (
p->bCollectNotifications )
3987 p->aNotifiedFormulaCells.push_back( pCell );
3991 p->aNotifiedFormulaCells.push_back( pCell );
3992 p->aNotifiedFormulaPos.push_back( pCell->
aPos );
4027 a->CompileAll(aCxt);
4054 pTab->CompileXML(aCxt, aProgress);
4076 bool bCompiled =
false;
4083 if (
a->CompileErrorCells(aCxt, nErrCode))
4101 a->CalcAfterLoad(aCxt, bStartListening);
4106 a->SetDirtyAfterLoad();
4119 for (
auto const& it : rListeners)
4131 return maTabs[nTab]->GetErrCode( rPos );
4132 return FormulaError::NONE;
4140 for (
SCTAB nTab = nTab1; nTab1 <= nTab2 && nTab <
nTabSize; ++nTab)
4142 maTabs[nTab]->ResetChanged(rRange);
4150 maTabs[nTab]->SetColWidth( nCol, nNewWidth );
4156 maTabs[nTab]->SetColWidthOnly( nCol, nNewWidth );
4162 maTabs[nTab]->SetRowHeight( nRow, nNewHeight );
4168 maTabs[nTab]->SetRowHeightRange
4169 ( nStartRow, nEndRow, nNewHeight, 1.0,
true );
4175 maTabs[nTab]->SetRowHeightOnly( nStartRow, nEndRow, nNewHeight );
4181 maTabs[nTab]->SetManualHeight( nStartRow, nEndRow, bManual );
4187 return maTabs[nTab]->GetColWidth( nCol, bHiddenAsZero );
4188 OSL_FAIL(
"wrong table number");
4204 return maTabs[nTab]->GetOriginalWidth( nCol );
4205 OSL_FAIL(
"wrong table number");
4212 return maTabs[nTab]->GetCommonWidth( nEndCol );
4213 OSL_FAIL(
"Wrong table number");
4220 return maTabs[nTab]->GetOriginalHeight( nRow );
4221 OSL_FAIL(
"Wrong table number");
4228 return maTabs[nTab]->GetRowHeight( nRow,
nullptr,
nullptr, bHiddenAsZero );
4229 OSL_FAIL(
"Wrong sheet number");
4236 return maTabs[nTab]->GetRowHeight( nRow, pStartRow, pEndRow, bHiddenAsZero );
4237 OSL_FAIL(
"Wrong sheet number");
4243 if (nStartRow == nEndRow)
4247 if (nStartRow > nEndRow)
4251 return maTabs[nTab]->GetRowHeight( nStartRow, nEndRow, bHiddenAsZero );
4253 OSL_FAIL(
"wrong sheet number");
4259 return maTabs[nTab]->GetRowForHeight(nHeight);
4263 SCTAB nTab,
double fScale )
const
4266 if (nStartRow == nEndRow)
4270 if (nStartRow > nEndRow)
4276 OSL_FAIL(
"wrong sheet number");
4283 return maTabs[nTab]->GetHiddenRowCount( nRow );
4284 OSL_FAIL(
"wrong table number");
4291 return maTabs[nTab]->GetColOffset( nCol, bHiddenAsZero );
4292 OSL_FAIL(
"wrong table number");
4299 return maTabs[nTab]->GetRowOffset( nRow, bHiddenAsZero );
4300 OSL_FAIL(
"wrong table number");
4312 rZoomX, rZoomY, bFormula, pMarkData, pParam );
4313 OSL_FAIL(
"wrong table number");
4321 bool bWidth,
bool bTotalSize,
bool bInPrintTwips )
4324 return maTabs[nTab]->GetNeededSize
4325 ( nCol, nRow, pDev,
nPPTX,
nPPTY, rZoomX, rZoomY, bWidth, bTotalSize, bInPrintTwips );
4326 OSL_FAIL(
"wrong table number");
4343 sal_uInt64 nCellCount = 0;
4344 for (
SCTAB nTab=0; nTab< static_cast<SCTAB>(
maTabs.size()); nTab++ )
4346 nCellCount +=
maTabs[nTab]->GetWeightedCount();
4350 sal_uInt64 nProgressStart = 0;
4351 for (
SCTAB nTab=0; nTab< static_cast<SCTAB>(
maTabs.size()); nTab++ )
4354 maTabs[nTab]->SetOptimalHeightOnly(rCxt, 0,
MaxRow(), &aProgress, nProgressStart);
4355 maTabs[nTab]->SetDrawPageSize();
4356 nProgressStart +=
maTabs[nTab]->GetWeightedCount();
4365 maTabs[nTab]->ShowCol( nCol, bShow );
4371 maTabs[nTab]->ShowRow( nRow, bShow );
4377 maTabs[nTab]->ShowRows( nRow1, nRow2, bShow );
4383 maTabs[nTab]->SetRowFlags( nRow, nNewFlags );
4389 maTabs[nTab]->SetRowFlags( nStartRow, nEndRow, nNewFlags );
4395 return maTabs[nTab]->GetColFlags( nCol );
4396 OSL_FAIL(
"wrong table number");
4403 return maTabs[nTab]->GetRowFlags( nRow );
4404 OSL_FAIL(
"wrong table number");
4412 maTabs[nTab]->GetAllRowBreaks(rBreaks, bPage, bManual);
4420 maTabs[nTab]->GetAllColBreaks(rBreaks, bPage, bManual);
4429 if (
maTabs[nTab]->HasRowPageBreak(nRow))
4432 if (
maTabs[nTab]->HasRowManualBreak(nRow))
4444 if (
maTabs[nTab]->HasColPageBreak(nCol))
4447 if (
maTabs[nTab]->HasColManualBreak(nCol))
4458 maTabs[nTab]->SetRowBreak(nRow, bPage, bManual);
4466 maTabs[nTab]->SetColBreak(nCol, bPage, bManual);
4474 maTabs[nTab]->RemoveRowBreak(nRow, bPage, bManual);
4482 maTabs[nTab]->RemoveColBreak(nCol, bPage, bManual);
4488 return Sequence<TablePageBreakData>();
4490 return maTabs[nTab]->GetRowBreakData();