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>
53 #include <stlpool.hxx>
54 #include <stlsheet.hxx>
55 #include <globstr.hrc>
71 #include <progress.hxx>
107 using ::editeng::SvxBorderLine;
110 namespace WritingMode2 = ::com::sun::star::text::WritingMode2;
111 using ::com::sun::star::uno::Sequence;
112 using ::com::sun::star::sheet::TablePageBreakData;
117 std::pair<SCTAB,SCTAB> getMarkedTableRange(
const std::vector<ScTableUniquePtr>& rTables,
const ScMarkData& rMark)
121 SCTAB nMax =
static_cast<SCTAB>(rTables.size());
122 for (
const auto& rTab : rMark)
130 if (rTab < nTabStart)
135 return std::pair<SCTAB,SCTAB>(nTabStart,nTabEnd);
138 void collectUIInformation(std::map<OUString, OUString>&& aParameters,
const OUString& rAction)
141 aDescription.
aID =
"grid_window";
142 aDescription.
aAction = rAction;
144 aDescription.
aParent =
"MainWindow";
145 aDescription.
aKeyWord =
"ScGridWinUIObject";
155 explicit ScDefaultAttr(
const ScPatternAttr* pPatAttr) : pAttr(pPatAttr), nFirst(0), nCount(0) {}
158 struct ScLessDefaultAttr
160 bool operator() (
const ScDefaultAttr& rValue1,
const ScDefaultAttr& rValue2)
const
162 return rValue1.pAttr < rValue2.pAttr;
178 if ( _bNeedsNameCheck )
180 if (nTab < static_cast<SCTAB>(
maTabs.size()))
186 while(nTab > static_cast<SCTAB>(
maTabs.size()))
187 maTabs.push_back(
nullptr);
208 rHashCode =
maTabs[nTab]->GetHashCode();
221 rName =
maTabs[nTab]->GetName();
242 maTabs[nTab]->SetCodeName( rName );
246 SAL_WARN(
"sc",
"can't set code name " << rName );
255 rName =
maTabs[nTab]->GetCodeName();
264 static OUString aCacheName, aCacheUpperName;
267 if (aCacheName != rName)
273 const OUString aUpperName = aCacheUpperName;
278 if (aUpperName ==
maTabs[i]->GetUpperName())
290 std::vector<OUString> aNames;
291 aNames.reserve(
maTabs.size());
302 aNames.push_back(aName);
311 return maTabs[nTab]->GetAnonymousDBData();
323 maTabs[nTab]->SetAnonymousDBData(std::move(pDBData));
340 sal_Int32 nLen = rName.getLength();
348 for (sal_Int32
i = 0;
i < nLen; ++
i)
363 if (
i == 0 ||
i == nLen - 1)
385 const OUString& rOldName =
a->GetUpperName();
386 bValid = rOldName != aUpperName;
407 OSL_ENSURE(bPrefix,
"Invalid Table Name");
410 for (
SCTAB i = static_cast<SCTAB>(
maTabs.size())+1; !bOk ;
i++ )
412 rName = aStrTable + OUString::number(static_cast<sal_Int32>(
i));
426 OUStringBuffer
aName;
432 aName.append(static_cast<sal_Int32>(i));
435 rName = aName.makeStringAndClear();
448 OUStringBuffer rName;
452 OSL_ENSURE(bPrefix,
"Invalid Table Name");
456 for (
SCTAB j = 0; j < nCount; ++j)
462 rName.append(static_cast<sal_Int32>(i));
466 bOk = !
GetTable( rName.toString(), nDummy );
469 aNames.push_back(rName.makeStringAndClear());
480 OUString
aName = rName;
493 maTabs[nTab]->SetName(rName);
501 a->SetStreamValid(
false);
506 SCTAB nPos,
const OUString& rName,
bool bExternalDocument,
bool bUndoDeleteTab )
510 if ( !bExternalDocument )
518 if ( bExternalDocument )
519 maTabs[nTabCount]->SetVisible(
false );
523 if (
ValidTab(nPos) && (nPos < nTabCount))
546 a->UpdateInsertTab(aCxt);
548 maTabs.emplace(maTabs.begin() + nPos,
new ScTable(*
this, nPos, rName));
554 for (
const auto&
a : maTabs)
596 SCTAB nNewSheets =
static_cast<SCTAB>(rNames.size());
598 bool bValid = bNamesValid ||
ValidTab(nTabCount+nNewSheets);
604 for (
SCTAB i = 0;
i < nNewSheets; ++
i )
606 maTabs.emplace_back(
new ScTable(*
this, nTabCount +
i, rNames.at(
i)) );
611 if (
ValidTab(nPos) && (nPos < nTabCount))
633 a->UpdateInsertTab(aCxt);
635 for (
SCTAB i = 0;
i < nNewSheets; ++
i)
637 maTabs.emplace(maTabs.begin() + nPos +
i,
new ScTable(*
this, nPos + i, rNames.at(i)) );
644 for (
const auto&
a : maTabs)
726 for (
auto & pTab :
maTabs)
728 pTab->UpdateDeleteTab(aCxt);
730 maTabs.erase(maTabs.begin() + nTab);
735 for (
const auto&
a : maTabs)
766 if (
ValidTab(nTab) && (nTab + nSheets) <= static_cast<SCTAB>(
maTabs.size()))
771 if (nTabCount > nSheets)
777 for (
SCTAB aTab = 0; aTab < nSheets; ++aTab)
819 for (
auto & pTab :
maTabs)
821 pTab->UpdateDeleteTab(aCxt);
823 maTabs.erase(maTabs.begin() + nTab, maTabs.begin() + nTab + nSheets);
828 for (
const auto&
a : maTabs)
864 if ( bExternalDocument )
868 for (i=0; (i< static_cast<SCTAB>(
maTabs.size())) && bValid; i++)
869 if (
maTabs[i] && (i != nTab))
871 OUString aOldName =
maTabs[i]->GetName();
880 maTabs[nTab]->SetName(rName);
887 a->SetStreamValid(
false );
899 collectUIInformation({{
"NewName", rName}},
"Rename_Sheet");
908 maTabs[nTab]->SetVisible(bVisible);
915 return maTabs[nTab]->IsVisible();
923 return maTabs[nTab]->IsStreamValid();
931 maTabs[nTab]->SetStreamValid( bSet, bIgnoreLock );
942 return maTabs[nTab]->IsPendingRowHeights();
950 maTabs[nTab]->SetPendingRowHeights( bSet );
964 maTabs[nTab]->SetLoadingRTL( bRTL );
968 maTabs[nTab]->SetLayoutRTL( bRTL );
969 maTabs[nTab]->SetDrawPageSize(
true,
true, eObjectHandling);
976 OSL_ENSURE(pPage,
"Page ?");
985 pObject = aIter.
Next();
992 return maTabs[nTab]->IsLayoutRTL();
1017 return maTabs[nTab]->GetCellArea( rEndCol, rEndRow );
1028 return maTabs[nTab]->GetTableArea( rEndCol, rEndRow, bCalcHiddens);
1042 maTabs[nTab]->GetFirstDataPos(nCol1, nRow1);
1043 maTabs[nTab]->GetLastDataPos(nCol2, nRow2);
1045 if (nCol1 > nCol2 || nRow1 > nRow2)
1050 if (rStartCol < nCol1)
1052 if (nCol2 < rEndCol)
1054 if (rStartRow < nRow1)
1056 if (nRow2 < rEndRow)
1059 if (rStartCol > rEndCol || rStartRow > rEndRow)
1068 bool bStickyTopRow,
bool bStickyLeftCol,
ScDataAreaExtras* pDataAreaExtras )
const
1075 return maTabs[nTab]->ShrinkToUsedDataArea(
1076 o_bShrunk, rStartCol, rStartRow, rEndCol, rEndRow, bColumnsOnly, bStickyTopRow,
1077 bStickyLeftCol, pDataAreaExtras);
1092 SCCOL& rEndCol,
SCROW& rEndRow,
bool bIncludeOld,
bool bOnlyDown )
const
1095 maTabs[nTab]->GetDataArea( rStartCol, rStartRow, rEndCol, rEndRow, bIncludeOld, bOnlyDown );
1101 if (nTab != rRange.
aEnd.
Tab())
1105 return maTabs[nTab]->GetDataAreaSubrange(rRange);
1115 maTabs[nTab]->LimitChartArea( rStartCol, rStartRow, rEndCol, rEndRow );
1121 if (rRangeList.
is())
1125 ScRange aRange( (*rRangeList)[
i] );
1134 if ( nTab < static_cast<SCTAB> (
maTabs.size()) &&
maTabs[nTab])
1135 maTabs[nTab]->LimitChartArea(nStartCol, nStartRow, nEndCol, nEndRow);
1146 OSL_FAIL(
"LimitChartIfAll: Ref==0");
1157 for (
SCTAB nTab=0; nTab< aMaxTab; ++nTab)
1164 rTabRangeEnd = nTab;
1174 for (
SCTAB nTab=rTabRangeEnd+1; nTab< aMaxTab; ++nTab)
1177 rTabRangeStart = nTab;
1180 rTabRangeEnd = nTab;
1198 SCSIZE nSize =
static_cast<SCSIZE>(nEndRow - nStartRow + 1);
1201 for (
SCTAB i=nStartTab; i<=nEndTab && bTest && i < static_cast<SCTAB>(
maTabs.size());
i++)
1203 bTest &=
maTabs[i]->TestInsertRow( nStartCol, nEndCol, nStartRow, nSize );
1210 struct SetDirtyIfPostponedHandler
1215 p->SetDirtyIfPostponed();
1219 struct BroadcastRecalcOnRefMoveHandler
1224 p->BroadcastRecalcOnRefMove();
1228 struct BroadcastRecalcOnRefMoveGuard
1230 explicit BroadcastRecalcOnRefMoveGuard(
ScDocument* pDoc ) :
1231 aSwitch( *pDoc,
false),
1264 for ( i = nStartTab; i <= nEndTab && bTest && i < static_cast<SCTAB>(
maTabs.size()); i++)
1266 bTest &=
maTabs[i]->TestInsertRow(nStartCol, nEndCol, nStartRow, nSize);
1273 SCTAB nTabRangeStart = nStartTab;
1274 SCTAB nTabRangeEnd = nEndTab;
1276 ScRange aShiftedRange(nStartCol, nStartRow, nTabRangeStart, nEndCol,
MaxRow(), nTabRangeEnd);
1279 std::vector<ScAddress> aGroupPos;
1314 for (i=nStartTab; i<=nEndTab && i < static_cast<SCTAB>(
maTabs.size()); i++)
1316 maTabs[i]->InsertRow( nStartCol, nEndCol, nStartRow, nSize );
1320 for (i=nStartTab; i<=nEndTab && i < static_cast<SCTAB>(
maTabs.size()); i++)
1323 nStartCol, nStartRow, nStartTab, nEndCol,
MaxRow(), nEndTab,
1324 0, static_cast<SCROW>(nSize), 0 );
1341 a->SetDirtyIfPostponed();
1345 BroadcastRecalcOnRefMoveGuard g(
this);
1346 std::for_each(maTabs.begin(), maTabs.end(), BroadcastRecalcOnRefMoveHandler());
1384 SCTAB nTabRangeStart = nStartTab;
1385 SCTAB nTabRangeEnd = nEndTab;
1392 ScAddress( nStartCol, nStartRow, nTabRangeStart ),
1393 ScAddress( nEndCol, nStartRow+nSize-1, nTabRangeEnd ) ) );
1395 ScAddress( nStartCol, nStartRow+nSize, nTabRangeStart ),
1396 ScAddress( nEndCol,
MaxRow(), nTabRangeEnd )), 0, -static_cast<SCROW>(nSize), 0 );
1400 ScAddress( nStartCol, nStartRow, nTabRangeStart ),
1407 if (
ValidRow(nStartRow+nSize) || bLastRowIncluded )
1412 if (bLastRowIncluded)
1419 aCxt.
maRange =
ScRange( nStartCol, nStartRow+nSize, nTabRangeStart, nEndCol,
MaxRow(), nTabRangeEnd);
1429 *pUndoOutline =
false;
1433 std::vector<ScAddress> aGroupPos;
1435 for ( i = nStartTab; i <= nEndTab && i < static_cast<SCTAB>(
maTabs.size()); i++)
1437 maTabs[i]->DeleteRow(aCxt.
maRegroupCols, nStartCol, nEndCol, nStartRow, nSize, pUndoOutline, &aGroupPos);
1446 if (
ValidRow(nStartRow+nSize) || bLastRowIncluded )
1456 a->SetDirtyIfPostponed();
1460 BroadcastRecalcOnRefMoveGuard g(
this);
1461 std::for_each(maTabs.begin(), maTabs.end(), BroadcastRecalcOnRefMoveHandler());
1487 SCSIZE nSize =
static_cast<SCSIZE>(nEndCol - nStartCol + 1);
1490 for (
SCTAB i=nStartTab; i<=nEndTab && bTest && i < static_cast<SCTAB>(
maTabs.size());
i++)
1492 bTest &=
maTabs[i]->TestInsertCol( nStartRow, nEndRow, nSize );
1518 for ( i = nStartTab; i <= nEndTab && bTest && i < static_cast<SCTAB>(
maTabs.size()); i++)
1520 bTest &=
maTabs[i]->TestInsertCol( nStartRow, nEndRow, nSize );
1524 SCTAB nTabRangeStart = nStartTab;
1525 SCTAB nTabRangeEnd = nEndTab;
1530 ScAddress( nStartCol, nStartRow, nTabRangeStart ),
1531 ScAddress(
MaxCol(), nEndRow, nTabRangeEnd )), static_cast<SCCOL>(nSize), 0, 0 );
1547 for (i=nStartTab; i<=nEndTab && i < static_cast<SCTAB>(
maTabs.size()); i++)
1565 std::for_each(
maTabs.begin(),
maTabs.end(), SetDirtyIfPostponedHandler());
1570 BroadcastRecalcOnRefMoveGuard g(
this);
1571 std::for_each(
maTabs.begin(),
maTabs.end(), BroadcastRecalcOnRefMoveHandler());
1592 bool* pUndoOutline,
const ScMarkData* pTabMark )
1608 SCTAB nTabRangeStart = nStartTab;
1609 SCTAB nTabRangeEnd = nEndTab;
1613 if (
ValidCol(sal::static_int_cast<SCCOL>(nStartCol+nSize)) )
1616 ScAddress( nStartCol, nStartRow, nTabRangeStart ),
1617 ScAddress( sal::static_int_cast<SCCOL>(nStartCol+nSize-1), nEndRow, nTabRangeEnd ) ) );
1619 ScAddress( sal::static_int_cast<SCCOL>(nStartCol+nSize), nStartRow, nTabRangeStart ),
1620 ScAddress(
MaxCol(), nEndRow, nTabRangeEnd )), -static_cast<SCCOL>(nSize), 0, 0 );
1624 ScAddress( nStartCol, nStartRow, nTabRangeStart ),
1631 if (
ValidCol(sal::static_int_cast<SCCOL>(nStartCol+nSize)) || bLastColIncluded )
1636 if (bLastColIncluded)
1643 aCxt.
maRange =
ScRange( sal::static_int_cast<SCCOL>(nStartCol+nSize), nStartRow, nTabRangeStart,
1644 MaxCol(), nEndRow, nTabRangeEnd);
1654 *pUndoOutline =
false;
1656 for (i = nStartTab; i <= nEndTab && i < static_cast<SCTAB>(
maTabs.size()); ++i)
1659 maTabs[i]->DeleteCol(aCxt.
maRegroupCols, nStartCol, nStartRow, nEndRow, nSize, pUndoOutline);
1662 if (
ValidCol(sal::static_int_cast<SCCOL>(nStartCol+nSize)) || bLastColIncluded )
1672 a->SetDirtyIfPostponed();
1676 BroadcastRecalcOnRefMoveGuard g(
this);
1677 std::for_each(maTabs.begin(), maTabs.end(), BroadcastRecalcOnRefMoveHandler());
1696 ScRange& rColRange,
bool& rInsCol,
bool& rDelCol,
1697 ScRange& rRowRange,
bool& rInsRow,
bool& rDelRow )
1699 OSL_ENSURE( rOld.
aStart == rNew.
aStart,
"FitBlock: Beginning is different" );
1701 rInsCol = rDelCol = rInsRow = rDelRow =
false;
1712 bool bGrowY = ( nNewEndY > nOldEndY );
1713 SCROW nColEndY = bGrowY ? nOldEndY : nNewEndY;
1714 SCCOL nRowEndX = bGrowY ? nNewEndX : nOldEndX;
1718 if ( nNewEndX > nOldEndX )
1720 rColRange =
ScRange( nOldEndX+1, nStartY, nTab, nNewEndX, nColEndY, nTab );
1723 else if ( nNewEndX < nOldEndX )
1725 rColRange =
ScRange( nNewEndX+1, nStartY, nTab, nOldEndX, nColEndY, nTab );
1731 if ( nNewEndY > nOldEndY )
1733 rRowRange =
ScRange( nStartX, nOldEndY+1, nTab, nRowEndX, nNewEndY, nTab );
1736 else if ( nNewEndY < nOldEndY )
1738 rRowRange =
ScRange( nStartX, nNewEndY+1, nTab, nRowEndX, nOldEndY, nTab );
1753 if (
HasAttrib( nStartX, nStartY, nTab, nEndX, nEndY, nTab,
1756 ExtendMerge( nStartX, nStartY, nEndX, nEndY, nTab );
1771 return maTabs[nTab]->ResolveStaticReference(rPos.
Col(), rPos.
Row());
1780 return maTabs[nTab]->ResolveStaticReference(
1790 return maTabs[nTab]->FetchVectorRefArray(rPos.
Col(), rPos.
Row(), rPos.
Row()+nLength-1);
1798 return maTabs[nTab]->AssertNoInterpretNeeded(rPos.
Col(), rPos.
Row(), rPos.
Row()+nLength-1);
1815 return maTabs[nTab]->HandleRefArrayForParallelism(rPos.
Col(), rPos.
Row(), rPos.
Row()+nLength-1, mxGroup);
1824 bool bInsCol,bDelCol,bInsRow,bDelRow;
1833 if ( bInsCol || bDelCol )
1839 if ( bInsRow || bDelRow )
1854 bool bInsCol,bDelCol,bInsRow,bDelRow;
1870 if ( bInsCol || bInsRow )
1890 std::vector<ScAddress> aGroupPos;
1898 ScRange aRange(nCol1, nRow1, 0, nCol2, nRow2, 0);
1899 for (
SCTAB i = 0; i < static_cast<SCTAB>(
maTabs.size());
i++)
1912 for (
SCTAB i = 0; i < static_cast<SCTAB>(
maTabs.size());
i++)
1915 maTabs[i]->
DeleteArea(nCol1, nRow1, nCol2, nRow2, nDelFlag, bBroadcast, pBroadcastSpans);
1927 if (aGroupPos.empty())
1930 ScRange aRange(nCol1, nRow1, 0, nCol2, nRow2, 0);
1931 for (
SCTAB i = 0; i < static_cast<SCTAB>(
maTabs.size()); i++)
1952 maTabs[nTab]->DeleteArea(nCol1, nRow1, nCol2, nRow2, nDelFlag);
1966 bool bColInfo,
bool bRowInfo )
1978 if (nTab < static_cast<SCTAB>(
maTabs.size()))
1979 maTabs[nTab] = std::move(pTable);
1981 maTabs.push_back(std::move(pTable));
1985 if (nTab < static_cast<SCTAB>(
maTabs.size()))
1988 maTabs.push_back(
nullptr);
1993 OSL_FAIL(
"InitUndo");
1998 bool bColInfo,
bool bRowInfo )
2002 OSL_FAIL(
"InitUndo");
2014 if ( nTab2 >= static_cast<SCTAB>(
maTabs.size()))
2015 maTabs.resize(nTab2 + 1);
2016 for (
SCTAB nTab = nTab1; nTab <= nTab2; nTab++)
2018 maTabs[nTab].reset(
new ScTable(*
this, nTab, OUString(), bColInfo, bRowInfo));
2026 OSL_FAIL(
"AddUndoTab");
2030 if (nTab2 >= static_cast<SCTAB>(
maTabs.size()))
2035 for (
SCTAB nTab = nTab1; nTab <= nTab2; nTab++)
2038 maTabs[nTab].reset(
new ScTable(*
this, nTab, OUString(), bColInfo, bRowInfo) );
2048 OSL_FAIL(
"SetCutMode without bIsClip");
2058 OSL_FAIL(
"IsCutMode without bIsClip");
2066 const ScMarkData* pMarks,
bool bColRowFlags )
2070 ScRange aThisRange(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
2071 CopyToDocument(aThisRange, nFlags, bOnlyMarked, rDestDoc, pMarks, bColRowFlags);
2091 assert( nTab2 < static_cast<SCTAB>(
maTabs.size()) && nTab2 < static_cast<SCTAB>(rDestDoc.
maTabs.size()));
2092 for (
SCTAB i = nTab1;
i <= nTab2;
i++)
2095 maTabs[
i]->UndoToTable(aCxt, nCol1, nRow1, nCol2, nRow2, nFlags,
2096 bOnlyMarked, rDestDoc.
maTabs[
i].get());
2125 if (!pTab || !pDestTab)
2130 nFlags, bOnlyMarked, pDestTab, pMarks,
false, bColRowFlags,
2152 for (
SCTAB i = nTab1;
i <= nTab2 &&
i < nMinSizeBothTabs;
i++)
2157 nFlags, bOnlyMarked, rDestDoc.
maTabs[
i].get());
2160 if (nTab2 < static_cast<SCTAB>(
maTabs.size()))
2166 bool bKeepScenarioFlags,
bool bIncludeObjects )
2168 OSL_ENSURE( pMarks,
"CopyToClip: ScMarkData fails" );
2175 SAL_WARN(
"sc",
"CopyToClip: no ClipDoc");
2192 for (
const auto& rxTab :
maTabs)
2196 OUString aTabName = rxTab->GetName();
2206 SCTAB nEndTab =
static_cast<SCTAB>(maTabs.size());
2213 for (
SCTAB i = 0;
i < nEndTab; ++
i)
2215 if (!maTabs[
i] ||
i >= static_cast<SCTAB>(pClipDoc->
maTabs.size()) || !pClipDoc->
maTabs[
i])
2221 maTabs[
i]->CopyToClip(aCxt, rClipParam.
maRanges, pClipDoc->
maTabs[
i].get());
2239 ScTable* pDestTab = nDestTab < static_cast<SCTAB>(rDestDoc.
maTabs.size()) ? rDestDoc.
maTabs[nDestTab].get() :
nullptr;
2241 if (!pSrcTab || !pDestTab)
2272 SAL_WARN(
"sc",
"CopyTabToClip: no ClipDoc");
2289 for (
const auto& rxTab :
maTabs)
2293 OUString aTabName = rxTab->GetName();
2310 if (nTab < static_cast<SCTAB>(maTabs.size()) && nTab < static_cast<SCTAB>(pClipDoc->
maTabs.size()))
2311 if (maTabs[nTab] && pClipDoc->
maTabs[nTab])
2312 maTabs[nTab]->CopyToClip(aCxt, nCol1, nRow1, nCol2, nRow2, pClipDoc->
maTabs[nTab].get());
2318 bool bIncludeFiltered)
2321 "TransposeClip with wrong Document" );
2335 sal_uInt16
nIndex = rEntry.second->GetIndex();
2346 SAL_WARN(
"sc",
"TransposeClip: Too big");
2356 const bool bIsMultiRangeRowFilteredTranspose
2363 if (bIsMultiRangeRowFilteredTranspose)
2370 SCROW nRowCount = 0;
2371 for (
size_t j = 0,
n = aClipRanges.
size(); j <
n; ++j)
2373 aClipRange = aClipRanges[j];
2375 SCROW nRowOffset = 0;
2376 if (bIsMultiRangeRowFilteredTranspose)
2379 nRowOffset = nRowCount;
2384 assert(!bIncludeFiltered &&
"bIsMultiRangeRowFilteredTranspose can only be true if bIncludeFiltered is false");
2385 nRowCount += nRowCountNonFiltered;
2388 for (
SCTAB i = 0; i < static_cast<SCTAB>(
maTabs.size());
i++)
2392 OSL_ENSURE(pTransClip->
maTabs[i],
"TransposeClip: Table not there");
2393 maTabs[i]->TransposeClip(
2396 pTransClip->
maTabs[i].get(), nFlags, bAsLink, bIncludeFiltered);
2420 bIsMultiRangeRowFilteredTranspose);
2432 pClipRangeName->
clear();
2433 for (
const auto& rEntry : *pRangeName)
2435 sal_uInt16
nIndex = rEntry.second->GetIndex();
2436 bool bInUse = (rUsedNames.count(nIndex) > 0);
2441 if (pClipRangeName->
insert(pData))
2450 if (!pRangeName || pRangeName->empty())
2455 for (
SCTAB i = 0;
i < nMinSizeBothTabs; ++
i)
2458 maTabs[
i]->FindRangeNamesInUse(
2464 copyUsedNamesToClip(pClipDoc->
GetRangeName(), pRangeName.get(), aUsedGlobalNames);
2476 mrDoc.pFormatExchangeList =
nullptr;
2506 if (!pTab || nLength <= 0)
2512 #if DUMP_COLUMN_STORAGE
2523 #if DEBUG_AREA_BROADCASTER
2524 void ScDocument::DumpAreaBroadcasters()
const
2541 return maTabs[nTab].get();
2549 return maTabs[nTab].get();
2556 SAL_WARN(
"sc",
"GetWritableColumnsRange() called for non-existent table");
2559 return maTabs[nTab]->GetWritableColumnsRange(nColBegin, nColEnd);
2566 return maTabs[nTab]->GetAllocatedColumnsRange(nColBegin, nColEnd);
2573 return maTabs[nTab]->GetColumnsRange(nColBegin, nColEnd);
2580 if (pOtherFormatter && pOtherFormatter != pThisFormatter)
2584 if (!pExchangeList->empty())
2622 auto pSet = std::make_shared<sc::ColumnBlockPositionSet>(*this);
2628 for (
const auto& rTab : rMark)
2633 maTabs[rTab]->StartListeningFormulaCells(aStartCxt, aEndCxt, nCol1, nRow1, nCol2, nRow2);
2644 for (
const auto& rTab : rMark)
2649 maTabs[rTab]->SetDirtyFromClip(nCol1, nRow1, nCol2, nRow2, rBroadcastSpans);
2659 return maTabs[nTab]->InitColumnBlockPosition(rBlockPos, nCol);
2673 while (!rClipTabs[nClipTab]) nClipTab = (nClipTab+1) % static_cast<SCTAB>(rClipTabs.size());
2676 rCxt, nCol1, nRow1, nCol2, nRow2, nDx, nDy, rClipTabs[nClipTab].
get());
2684 OSL_ENSURE(
mpDrawLayer,
"CopyBlockFromClip: No drawing layer" );
2692 nCol1-nDx, nRow1-nDy, nCol2-nDx, nRow2-nDy, nClipTab );
2699 nClipTab = (nClipTab+1) % static_cast<SCTAB>(rClipTabs.size());
2710 while (!rClipTabs[nClipTab]) nClipTab = (nClipTab+1) % static_cast<SCTAB>(rClipTabs.size());
2711 SCTAB nDz =
i - nClipTab;
2716 while (
i + nFollow < nTabEnd
2718 && nClipTab + nFollow <
MAXTAB
2719 && rClipTabs[(nClipTab + nFollow + 1) % static_cast<SCTAB>(rClipTabs.size())] )
2724 aRefCxt.mnColDelta = nDx;
2725 aRefCxt.mnRowDelta = nDy;
2726 aRefCxt.mnTabDelta = nDz;
2741 if (!aRefCxt.maRegroupCols.empty())
2746 auto pColSet = std::make_shared<sc::ColumnSet>( aRefCxt.maRegroupCols);
2759 nClipTab = (nClipTab+nFollow+1) % static_cast<SCTAB>(rClipTabs.size());
2760 i = sal::static_int_cast<
SCTAB>(
i + nFollow );
2775 while ( nFlagTab < static_cast<SCTAB>(rClipTabs.size()) && !rClipTabs[nFlagTab] )
2778 SCROW nSourceRow = rClipStartRow;
2779 SCROW nSourceEnd = nClipEndRow;
2780 SCROW nDestRow = nRow1;
2781 SCROW nFilteredRows = 0;
2783 while ( nSourceRow <= nSourceEnd && nDestRow <= nRow2 )
2786 SCROW nSourceRowOriginal = nSourceRow;
2788 nFilteredRows += nSourceRow - nSourceRowOriginal;
2790 if ( nSourceRow <= nSourceEnd )
2793 SCROW nLastRow = nSourceRow;
2795 SCROW nFollow = nLastRow - nSourceRow;
2797 if (nFollow > nSourceEnd - nSourceRow)
2798 nFollow = nSourceEnd - nSourceRow;
2799 if (nFollow > nRow2 - nDestRow)
2800 nFollow = nRow2 - nDestRow;
2802 SCROW nNewDy = nDestRow - nSourceRow;
2804 rCxt, nCol1, nDestRow, nCol2, nDestRow + nFollow, rMark, nDx, nNewDy);
2806 nSourceRow += nFollow + 1;
2807 nDestRow += nFollow + 1;
2810 rClipStartRow = nSourceRow;
2811 return nFilteredRows;
2822 explicit BroadcastAction(
ScDocument& rDoc ) : mrDoc(rDoc), mpCol(nullptr) {}
2824 virtual void startColumn(
ScColumn* pCol )
override
2829 virtual void execute(
SCROW nRow1,
SCROW nRow2,
bool bVal )
override
2846 bool bAsLink,
bool bIncludeFiltered,
bool bSkipEmptyCells,
2854 OSL_FAIL(
"CopyFromClip: no ClipDoc");
2873 for (
SCTAB nTab = 0; nTab < static_cast<SCTAB>(pClipDoc->
maTabs.size()); nTab++)
2874 if (pClipDoc->
maTabs[nTab])
2880 nThisEndX, nThisEndY, nTab );
2882 nThisEndX = sal::static_int_cast<
SCCOL>( nThisEndX - aClipRange.
aEnd.
Col() );
2883 nThisEndY = sal::static_int_cast<
SCROW>( nThisEndY - aClipRange.
aEnd.
Row() );
2884 if ( nThisEndX > nXw )
2886 if ( nThisEndY > nYw )
2892 pClipDoc->
GetClipArea( nDestAddX, nDestAddY, bIncludeFiltered );
2893 nXw = sal::static_int_cast<
SCCOL>( nXw + nDestAddX );
2894 nYw = sal::static_int_cast<
SCROW>( nYw + nDestAddY );
2913 std::pair<SCTAB,SCTAB> aTabRanges = getMarkedTableRange(
maTabs, rMark);
2914 aCxt.
setTabRange(aTabRanges.first, aTabRanges.second);
2921 pDestRanges = &aLocalRangeList;
2931 for (
size_t nRange = 0; nRange < pDestRanges->
size(); ++nRange )
2933 const ScRange & rRange = (*pDestRanges)[nRange];
2947 SCCOL nC2 = nC1 + nXw;
2950 SCROW nR2 = nR1 + nYw;
2956 std::vector< SCTAB > vTables;
2958 if (bPreallocatePattern)
2962 vTables.push_back(
i );
2972 SCROW nSaveClipStartRow = nClipStartRow;
2975 nClipStartRow = nSaveClipStartRow;
2976 SCCOL nDx = nC1 - nClipStartCol;
2977 SCROW nDy = nR1 - nClipStartRow;
2978 if ( bIncludeFiltered )
2981 aCxt, nC1, nR1, nC2, nR2, rMark, nDx, nDy);
2982 nClipStartRow += nR2 - nR1 + 1;
2990 nC2 = std::min(static_cast<SCCOL>(nC1 + nXw), nCol2);
2991 }
while (nC1 <= nCol2);
2992 if (nClipStartRow > nClipEndRow)
2993 nClipStartRow = aClipRange.
aStart.
Row();
3000 if (bPreallocatePattern && (nR2+1) <= nRow2)
3002 SCROW nR3 = nR2 + 1;
3003 for (
SCTAB nTab : vTables)
3005 for (
SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
3016 SCSIZE nNeeded = nChunk * (nRow2 - nR3 + 1) / (nYw + 1);
3018 if (nNeeded > nRemain)
3026 bPreallocatePattern =
false;
3030 nR2 = std::min(static_cast<SCROW>(nR1 + nYw), nRow2);
3031 }
while (nR1 <= nRow2);
3044 SetDirtyFromClip(nAllCol1, nAllRow1, nAllCol2, nAllRow2, rMark, nInsFlag, aBroadcastSpans);
3046 BroadcastAction aAction(*
this);
3056 bool bResetCut,
bool bAsLink,
bool bIncludeFiltered,
3057 bool bSkipAttrForEmpty)
3081 if (!bSkipAttrForEmpty)
3091 std::pair<SCTAB,SCTAB> aTabRanges = getMarkedTableRange(
maTabs, rMark);
3092 aCxt.
setTabRange(aTabRanges.first, aTabRanges.second);
3102 SCROW nEndRow = nRow1 + nRowCount - 1;
3103 SCROW nFilteredRows = 0;
3105 if (bIncludeFiltered)
3114 nClipStartRow, nClipEndRow);
3115 nRowCount -= nFilteredRows;
3144 rMark, nInsFlag, aBroadcastSpans);
3146 BroadcastAction aAction(*
this);
3165 OSL_FAIL(
"SetClipArea: No Clip");
3173 OSL_FAIL(
"GetClipArea: No Clip");
3178 if (rClipRanges.
empty())
3187 for (
size_t i = 1,
n = rClipRanges.
size();
i <
n; ++
i )
3189 ScRange const & rRange2 = rClipRanges[
i ];
3194 if (rRange2.
aEnd.
Col() > nEndCol)
3196 if (rRange2.
aEnd.
Row() > nEndRow)
3200 nClipX = nEndCol - nStartCol;
3202 if ( bIncludeFiltered )
3203 nClipY = nEndRow - nStartRow;
3208 SCTAB nCountTab = 0;
3209 while ( nCountTab < static_cast<SCTAB>(
maTabs.size()) && !
maTabs[nCountTab] )
3215 nClipY = nResult - 1;
3226 if ( !rClipRanges.
empty() )
3234 OSL_FAIL(
"GetClipStart: No Clip");
3241 SCTAB nCountTab = 0;
3242 while ( nCountTab < static_cast<SCTAB>(
maTabs.size()) && !
maTabs[nCountTab] )
3246 if ( rClipRanges.
empty() )
3249 for (
size_t i = 0,
n = rClipRanges.
size();
i <
n; ++
i )
3251 ScRange & rRange = rClipRanges[
i ];
3266 for (
SCTAB i = nTab1;
i <= nTab2 &&
i < nMinSizeBothTabs;
i++)
3270 if (!pTab || !pSrcTab)
3275 nFunction, bSkipEmpty, pSrcTab);
3281 bool bSkipEmpty,
bool bAsLink )
3296 bool bDoMix = ( bSkipEmpty || nFunction !=
ScPasteFunc::NONE ) && ( nFlags & InsertDeleteFlags::CONTENTS );
3305 for (
const SCTAB&
i : rMark)
3316 pMixDoc->InitUndo( *
this, i, i );
3319 pMixDoc->AddUndoTab( i, i );
3323 maTabs[i]->CopyToTable(aMixCxt, nStartCol,nStartRow, nEndCol,nEndRow,
3324 InsertDeleteFlags::CONTENTS,
false, pMixDoc->maTabs[i].get(),
3325 nullptr,
false,
true,
3328 maTabs[i]->DeleteArea( nStartCol,nStartRow, nEndCol,nEndRow, nDelFlags);
3329 maTabs[nSrcTab]->CopyToTable(aCxt, nStartCol,nStartRow, nEndCol,nEndRow,
3330 nFlags,
false,
maTabs[i].
get(),
nullptr, bAsLink,
3331 true,
false,
true );
3334 maTabs[i]->MixData(aMixDocCxt, nStartCol,nStartRow, nEndCol,nEndRow,
3335 nFunction, bSkipEmpty, pMixDoc->maTabs[i].get() );
3343 OSL_FAIL(
"wrong table");
3349 bool bSkipEmpty,
bool bAsLink )
3358 bool bDoMix = ( bSkipEmpty || nFunction !=
ScPasteFunc::NONE ) && ( nFlags & InsertDeleteFlags::CONTENTS );
3372 for (
const SCTAB&
i : rMark)
3383 pMixDoc->InitUndo( *
this, i, i );
3386 pMixDoc->AddUndoTab( i, i );
3389 maTabs[i]->CopyToTable(aMixCxt, nStartCol,nStartRow, nEndCol,nEndRow,
3390 InsertDeleteFlags::CONTENTS,
true, pMixDoc->maTabs[i].get(), &rMark,
3395 maTabs[i]->DeleteSelection( nDelFlags, rMark );
3396 maTabs[nSrcTab]->CopyToTable(aCxt, nStartCol,nStartRow, nEndCol,nEndRow,
3397 nFlags,
true,
maTabs[i].
get(), &rMark, bAsLink,
3398 true,
false,
true );
3401 maTabs[i]->MixMarked(aMixDocCxt, rMark, nFunction, bSkipEmpty, pMixDoc->maTabs[i].get());
3409 OSL_FAIL(
"wrong table");
3421 if (pCurCellFormula && pCurCellFormula->
IsShared())
3435 return pTab->
SetString(nCol, nRow, nTab, rString, pParam);
3451 return maTabs[rPos.
Tab()]->SetEditText(rPos.
Col(), rPos.
Row(), std::move(pEditText));
3459 maTabs[rPos.
Tab()]->SetEditText(rPos.
Col(), rPos.
Row(), rEditText, pEditPool);
3520 if (pCurCellFormula && pCurCellFormula->
IsShared())
3539 return maTabs[nTab]->GetString(nCol, nRow, pContext);
3548 return maTabs[rPos.
Tab()]->GetString(rPos.
Col(), rPos.
Row(), pContext);
3586 return maTabs[nTab]->GetInputString( nCol, nRow,
nullptr, bForceSystemLocale );
3601 return FormulaError::NONE;
3621 SvNumFormatType::NUMBER,
3633 SvNumFormatType::NUMBER,
3652 return maTabs[nTab]->GetEditText(rPos.
Col(), rPos.
Row());
3660 return maTabs[rPos.
Tab()]->RemoveEditTextCharAttribs(rPos.
Col(), rPos.
Row(), rAttr);
3666 if ( nTab < static_cast<SCTAB>(
maTabs.size()) &&
maTabs[nTab] )
3682 return maTabs[nTab]->GetNumberFormat( nCol, nRow );
3696 sal_uInt32 nFormat = 0;
3697 bool bFirstItem =
true;
3698 for (
SCTAB nTab = nTab1; nTab <= nTab2 && nTab < static_cast<SCTAB>(
maTabs.size()) ; ++nTab)
3699 for (
SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
3701 sal_uInt32 nThisFormat =
maTabs[nTab]->GetNumberFormat(nCol, nRow1, nRow2);
3704 nFormat = nThisFormat;
3707 else if (nThisFormat != nFormat)
3720 return maTabs[nTab]->GetNumberFormat( rContext, rPos );
3730 maTabs[nTab]->SetNumberFormat(rPos.
Col(), rPos.
Row(), nNumberFormat);
3737 if ( nTab < static_cast<SCTAB>(
maTabs.size()) &&
maTabs[nTab] )
3739 nIndex =
maTabs[nTab]->GetNumberFormat( rContext, rPos );
3744 nType = SvNumFormatType::UNDEFINED;
3752 return maTabs[nTab]->GetFormula( nCol, nRow );
3776 if ( nTab < static_cast<SCTAB>(
maTabs.size()) &&
maTabs[nTab] )
3777 return maTabs[nTab]->GetCellType( rPos );
3784 return maTabs[nTab]->GetCellType( nCol, nRow );
3823 for (
SCTAB nTab=nStartTab; nTab<=nEndTab && nTab < static_cast<SCTAB>(
maTabs.size()); nTab++ )
3862 a->CheckVectorizationState();
3877 a->SetAllFormulasDirty(rCxt);
3905 if (bIncludeEmptyCells)
3928 for (
size_t nPos=0, nRangeCount = rRanges.
size();
nPos < nRangeCount;
nPos++)
3948 for (
size_t nPos=0, nRangeCount = rRanges.
size();
nPos < nRangeCount;
nPos++)
3993 for (
const auto&
a : maTabs)
4013 a->CompileAll(aCxt);
4034 pRangeName->CompileUnresolvedXML(aCxt);
4062 bool bCompiled =
false;
4069 if (
a->CompileErrorCells(aCxt, nErrCode))
4087 a->CalcAfterLoad(aCxt, bStartListening);
4089 for (
const auto&
a : maTabs)
4092 a->SetDirtyAfterLoad();
4105 for (
auto const& it : rListeners)
4116 if ( nTab < static_cast<SCTAB>(
maTabs.size()) &&
maTabs[nTab] )
4117 return maTabs[nTab]->GetErrCode( rPos );
4118 return FormulaError::NONE;
4126 for (
SCTAB nTab = nTab1; nTab1 <= nTab2 && nTab < nTabSize; ++nTab)
4128 maTabs[nTab]->ResetChanged(rRange);
4136 maTabs[nTab]->SetColWidth( nCol, nNewWidth );
4142 maTabs[nTab]->SetColWidthOnly( nCol, nNewWidth );
4148 maTabs[nTab]->SetRowHeight( nRow, nNewHeight );
4154 maTabs[nTab]->SetRowHeightRange
4155 ( nStartRow, nEndRow, nNewHeight, 1.0,
true );
4161 maTabs[nTab]->SetRowHeightOnly( nStartRow, nEndRow, nNewHeight );
4167 maTabs[nTab]->SetManualHeight( nStartRow, nEndRow, bManual );
4173 return maTabs[nTab]->GetColWidth( nCol, bHiddenAsZero );
4174 OSL_FAIL(
"wrong table number");
4190 return maTabs[nTab]->GetOriginalWidth( nCol );
4191 OSL_FAIL(
"wrong table number");
4198 return maTabs[nTab]->GetCommonWidth( nEndCol );
4199 OSL_FAIL(
"Wrong table number");
4206 return maTabs[nTab]->GetOriginalHeight( nRow );
4207 OSL_FAIL(
"Wrong table number");
4214 return maTabs[nTab]->GetRowHeight( nRow,
nullptr,
nullptr, bHiddenAsZero );
4215 OSL_FAIL(
"Wrong sheet number");
4222 return maTabs[nTab]->GetRowHeight( nRow, pStartRow, pEndRow, bHiddenAsZero );
4223 OSL_FAIL(
"Wrong sheet number");
4229 if (nStartRow == nEndRow)
4233 if (nStartRow > nEndRow)
4237 return maTabs[nTab]->GetRowHeight( nStartRow, nEndRow, bHiddenAsZero );
4239 OSL_FAIL(
"wrong sheet number");
4245 return maTabs[nTab]->GetRowForHeight(nHeight);
4252 if (nStartRow == nEndRow)
4256 if (nStartRow > nEndRow)
4260 return maTabs[nTab]->GetScaledRowHeight( nStartRow, nEndRow, fScale, pnMaxHeight );
4262 OSL_FAIL(
"wrong sheet number");
4269 return maTabs[nTab]->GetHiddenRowCount( nRow );
4270 OSL_FAIL(
"wrong table number");
4277 return maTabs[nTab]->GetColOffset( nCol, bHiddenAsZero );
4278 OSL_FAIL(
"wrong table number");
4285 return maTabs[nTab]->GetRowOffset( nRow, bHiddenAsZero );
4286 OSL_FAIL(
"wrong table number");
4297 return maTabs[nTab]->GetOptimalColWidth( nCol, pDev, nPPTX, nPPTY,
4298 rZoomX, rZoomY, bFormula, pMarkData, pParam );
4299 OSL_FAIL(
"wrong table number");
4307 bool bWidth,
bool bTotalSize,
bool bInPrintTwips )
4310 return maTabs[nTab]->GetNeededSize
4311 ( nCol, nRow, pDev, nPPTX, nPPTY, rZoomX, rZoomY, bWidth, bTotalSize, bInPrintTwips );
4312 OSL_FAIL(
"wrong table number");
4329 sal_uInt64 nCellCount = 0;
4330 for (
SCTAB nTab=0; nTab< static_cast<SCTAB>(
maTabs.size()); nTab++ )
4332 nCellCount +=
maTabs[nTab]->GetWeightedCount();
4336 sal_uInt64 nProgressStart = 0;
4337 for (
SCTAB nTab=0; nTab< static_cast<SCTAB>(
maTabs.size()); nTab++ )
4340 maTabs[nTab]->SetOptimalHeightOnly(rCxt, 0,
MaxRow(), &aProgress, nProgressStart);
4341 maTabs[nTab]->SetDrawPageSize();
4342 nProgressStart +=
maTabs[nTab]->GetWeightedCount();
4351 maTabs[nTab]->ShowCol( nCol, bShow );
4357 maTabs[nTab]->ShowRow( nRow, bShow );
4363 maTabs[nTab]->ShowRows( nRow1, nRow2, bShow );
4369 maTabs[nTab]->SetRowFlags( nRow, nNewFlags );
4375 maTabs[nTab]->SetRowFlags( nStartRow, nEndRow, nNewFlags );
4381 return maTabs[nTab]->GetColFlags( nCol );
4382 OSL_FAIL(
"wrong table number");
4389 return maTabs[nTab]->GetRowFlags( nRow );
4390 OSL_FAIL(
"wrong table number");
4398 maTabs[nTab]->GetAllRowBreaks(rBreaks, bPage, bManual);
4406 maTabs[nTab]->GetAllColBreaks(rBreaks, bPage, bManual);
4415 if (
maTabs[nTab]->HasRowPageBreak(nRow))
4418 if (
maTabs[nTab]->HasRowManualBreak(nRow))
4430 if (
maTabs[nTab]->HasColPageBreak(nCol))
4433 if (
maTabs[nTab]->HasColManualBreak(nCol))
4444 maTabs[nTab]->SetRowBreak(nRow, bPage, bManual);
4452 maTabs[nTab]->SetColBreak(nCol, bPage, bManual);
4460 maTabs[nTab]->RemoveRowBreak(nRow, bPage, bManual);
4468 maTabs[nTab]->RemoveColBreak(nCol, bPage, bManual);
4474 return Sequence<TablePageBreakData>();
4476 return maTabs[nTab]->GetRowBreakData();
4484 return maTabs[nTab]->RowHidden(nRow, pFirstRow, pLastRow);
4492 return maTabs[nTab]->HasHiddenRows(nStartRow, nEndRow);
4506 return maTabs[nTab]->ColHidden(nCol, pFirstCol, pLastCol);
4514 maTabs[nTab]->SetRowHidden(nStartRow, nEndRow, bHidden);
4522 maTabs[nTab]->SetColHidden(nStartCol, nEndCol, bHidden);
4528 return ::std::numeric_limits<SCROW>::max();
4530 return maTabs[nTab]->FirstVisibleRow(nStartRow, nEndRow);
4536 return ::std::numeric_limits<SCROW>::max();
4538 return maTabs[nTab]->LastVisibleRow(nStartRow, nEndRow);
4546 return maTabs[nTab]->CountVisibleRows(nStartRow, nEndRow);
4554 return maTabs[nTab]->RowFiltered(nRow, pFirstRow, pLastRow);
4562 return maTabs[nTab]->HasFilteredRows(nStartRow, nEndRow);
4570 return maTabs[nTab]->ColFiltered(nCol);
4578 maTabs[nTab]->SetRowFiltered(nStartRow, nEndRow, bFiltered);
4584 return ::std::numeric_limits<SCROW>::max();
4586 return maTabs[nTab]->FirstNonFilteredRow(nStartRow, nEndRow);
4592 return ::std::numeric_limits<SCROW>::max();
4594 return maTabs[nTab]->LastNonFilteredRow(nStartRow, nEndRow);
4602 return maTabs[nTab]->CountNonFilteredRows(nStartRow, nEndRow);
4610 return maTabs[nTab]->IsManualRowHeight(nRow);
4618 a->SyncColRowFlags();
4625 return maTabs[nTab]->GetLastFlaggedRow();
4632 return maTabs[nTab]->GetLastChangedColFlagsWidth();
4639 return maTabs[nTab]->GetLastChangedRowFlagsWidth();
4648 sal_uInt16 nStartWidth =
maTabs[nTab]->GetOriginalWidth(nStart);
4667 if (!pRowFlagsArray)
4670 if (!
maTabs[nTab]->mpRowHeights || !
maTabs[nTab]->mpHiddenRows)
4675 SCROW nHiddenEndRow;
4676 SCROW nHeightEndRow;
4680 CRFlags nStartFlags = nFlags = pRowFlagsArray->
GetValue( nStart, nIndex, nFlagsEndRow);
4681 bool bStartHidden = bHidden =
maTabs[nTab]->RowHidden( nStart,
nullptr, &nHiddenEndRow);
4682 sal_uInt16 nStartHeight = nHeight =
maTabs[nTab]->GetRowHeight( nStart,
nullptr, &nHeightEndRow,
false);
4684 while ((nRow = std::min( nHiddenEndRow, std::min( nFlagsEndRow, nHeightEndRow)) + 1) <=
MaxRow())
4686 if (nFlagsEndRow < nRow)
4687 nFlags = pRowFlagsArray->
GetValue( nRow, nIndex, nFlagsEndRow);
4688 if (nHiddenEndRow < nRow)
4689 bHidden =
maTabs[nTab]->RowHidden( nRow,
nullptr, &nHiddenEndRow);
4690 if (nHeightEndRow < nRow)
4691 nHeight =
maTabs[nTab]->GetRowHeight( nRow,
nullptr, &nHeightEndRow,
false);
4695 (bStartHidden != bHidden) ||
4696 (nStartHeight != nHeight))
4711 if (nEndRow >= nLastRow)
4714 ScDefaultAttrSet aSet;
4715 ScDefaultAttrSet::iterator aItr = aSet.end();
4718 ScDefaultAttr aAttr(pAttr);
4719 aItr = aSet.find(aAttr);
4720 if (aItr == aSet.end())
4722 aAttr.nCount =
static_cast<SCSIZE>(nEndRow - nStartRow + 1);
4723 aAttr.nFirst = nStartRow;
4728 aAttr.nCount = aItr->nCount +
static_cast<SCSIZE>(nEndRow - nStartRow + 1);
4729 aAttr.nFirst = aItr->nFirst;
4733 pAttr = aDocAttrItr.
GetNext(nColumn, nStartRow, nEndRow);
4735 ScDefaultAttrSet::iterator aDefaultItr = aSet.begin();
4738 while (aItr != aSet.end())
4742 if ( aItr->nCount > aDefaultItr->nCount ||
4743 ( aItr->nCount == aDefaultItr->nCount && aItr->nFirst < aDefaultItr->nFirst ) )
4747 nDefault = aDefaultItr->nFirst;
4753 maTabs[nTab]->StripHidden( rX1, rY1, rX2, rY2 );
4759 maTabs[nTab]->ExtendHidden( rX1, rY1, rX2, rY2 );
4773 OSL_FAIL(
"Attribute Null" );
4776 return &
mxPoolHelper->GetDocPool()->GetDefaultItem( nWhich );
4783 const SfxPoolItem* pTemp =
maTabs[nTab]->GetAttr( nCol, nRow, nWhich, nStartRow, nEndRow );
4788 OSL_FAIL(
"Attribute Null" );
4791 return &
mxPoolHelper->GetDocPool()->GetDefaultItem( nWhich );
4802 return maTabs[nTab]->GetPattern( nCol, nRow );