26#include <osl/diagnose.h>
30#include <document.hxx>
38#include <progress.hxx>
66 if (nTotalCount < 1000)
75 return pOuterProgress;
84void GetOptimalHeightsInColumn(
88 assert(nStartRow <= nEndRow);
100 sal_uInt16 nMinHeight = rHeights.
GetValue(nEndRow);
105 if (aRangeData.maValue < nMinHeight)
107 nPos = std::max<SCSIZE>(0, aRangeData.mnRow1);
114 for (
SCCOL nCol=0; nCol<maxCol; nCol++)
116 rCol[nCol].GetOptimalHeight(rCxt, nStartRow, nEndRow, nMinHeight, nMinStart);
120 nWeightedCount += rCol[nCol].GetWeightedCount(nStartRow, nEndRow);
121 pProgress->
SetState( nWeightedCount );
126struct OptimalHeightsFuncObjBase
128 virtual ~OptimalHeightsFuncObjBase() {}
129 virtual bool operator() (
SCROW nStartRow,
SCROW nEndRow, sal_uInt16 nHeight,
bool bApi) = 0;
132struct SetRowHeightOnlyFunc :
public OptimalHeightsFuncObjBase
135 explicit SetRowHeightOnlyFunc(
ScTable* pTab) :
139 virtual bool operator() (
SCROW nStartRow,
SCROW nEndRow, sal_uInt16 nHeight,
bool )
override
146struct SetRowHeightRangeFunc :
public OptimalHeightsFuncObjBase
156 virtual bool operator() (
SCROW nStartRow,
SCROW nEndRow, sal_uInt16 nHeight,
bool bApi)
override
162bool SetOptimalHeightsToRows(
164 OptimalHeightsFuncObjBase& rFuncObj,
168 bool bChanged =
false;
171 sal_uInt16 nLast = 0;
178 if ( nRegionEndRow > nEndRow )
179 nRegionEndRow = nEndRow;
180 SCSIZE nMoreRows = nRegionEndRow -
i;
193 for (
SCSIZE nInner = i; nInner <=
i + nMoreRows; ++nInner)
200 if (nRangeValue + nExtraHeight == nLast)
202 nRngEnd = std::min<SCSIZE>(i + nMoreRows, nRangeRowEnd);
203 nInner = nRangeRowEnd;
207 bChanged |= rFuncObj(nRngStart, nRngEnd, nLast, bApi);
222 bChanged |= rFuncObj(nRngStart, nRngEnd, nLast, bApi);
228 bChanged |= rFuncObj(nRngStart, nRngEnd, nLast, bApi);
236 bool bColInfo,
bool bRowInfo ) :
239 aCodeName( rNewName ),
240 nLinkRefreshDelay( 0 ),
242 aPageStyle(
ScResId(STR_STYLENAME_STANDARD) ),
247 mbCellAreaDirty( true ),
248 mbCellAreaEmpty( true ),
258 nTableAreaVisibleX( 0 ),
259 nTableAreaVisibleY( 0 ),
262 pSortCollator( nullptr ),
268 maLOKFreezeCell(-1, -1, nNewTab),
272 bPageSizeValid(false),
273 bTableAreaValid(false),
274 bTableAreaVisibleValid(false),
276 bPendingRowHeights(false),
277 bCalcNotification(false),
278 bGlobalKeepQuery(false),
279 bPrintEntireSheet(true),
280 bActiveScenario(false),
281 mbPageBreaksValid(false),
282 mbForceBreaks(false),
327 aCol[nCol].FreeNotes();
352 return sal::static_int_cast<sal_Int64>(
reinterpret_cast<sal_IntPtr
>(
this));
417 const OUString& rDoc,
const OUString& rFlt,
const OUString& rOpt,
418 const OUString& rTab,
sal_uLong nRefreshDelay )
439 return aCol[nCol].GetOptimalColWidth( pDev,
nPPTX,
nPPTY, rZoomX, rZoomY,
447 bool bWidth,
bool bTotalSize,
bool bInPrintTwips )
456 return aCol[nCol].GetNeededSize
457 ( nRow, pDev,
nPPTX,
nPPTY, rZoomX, rZoomY, bWidth, aOptions,
nullptr, bInPrintTwips );
462 ScProgress* pOuterProgress, sal_uInt64 nProgressStart )
464 assert(nStartRow <= nEndRow);
467 "automatic OptimalHeight with Extra" );
480 GetOptimalHeightsInColumn(rCxt,
aCol, nStartRow, nEndRow, pProgress, nProgressStart);
482 SetRowHeightRangeFunc aFunc(
this, rCxt.
getPPTY());
483 bool bChanged = SetOptimalHeightsToRows(rCxt, aFunc,
pRowFlags.get(), nStartRow, nEndRow, bApi);
485 if ( pProgress != pOuterProgress )
495 ScProgress* pOuterProgress, sal_uInt64 nProgressStart )
498 "automatic OptimalHeight with Extra" );
507 GetOptimalHeightsInColumn(rCxt,
aCol, nStartRow, nEndRow, pProgress, nProgressStart);
509 SetRowHeightOnlyFunc aFunc(
this);
511 SetOptimalHeightsToRows(rCxt, aFunc,
pRowFlags.get(), nStartRow, nEndRow,
true);
513 if ( pProgress != pOuterProgress )
539 if (
aCol[
i].HasCellNotes() )
541 SCROW maxNoteRow =
aCol[
i].GetCellNotesMaxRow();
542 if (maxNoteRow >= nMaxY)
553 if (
aCol[
i].HasSparklines())
555 SCROW maxSparklineRow =
aCol[
i].GetSparklinesMaxRow();
556 if (maxSparklineRow >= nMaxY)
559 nMaxY = maxSparklineRow;
624 if (bNotes &&
aCol[
i].HasCellNotes() )
626 SCROW maxNoteRow =
aCol[
i].GetCellNotesMaxRow();
627 if (maxNoteRow >= nMaxY)
638 if (
aCol[
i].HasSparklines())
640 SCROW maxSparklineRow =
aCol[
i].GetSparklinesMaxRow();
641 if (maxSparklineRow >= nMaxY)
644 nMaxY = maxSparklineRow;
655 SCCOL nMaxDataX = nMaxX;
662 if (
aCol[
i].GetLastVisibleAttr( nLastRow ))
666 if (nLastRow > nMaxY)
679 if ( nMaxX < nMaxDataX )
683 else if ( nMaxX > nMaxDataX )
685 SCCOL nAttrStartX = nMaxDataX + 1;
686 while ( nAttrStartX < (
aCol.
size()-1) )
688 SCCOL nAttrEndX = nAttrStartX;
694 nMaxX = nAttrStartX - 1;
698 while ( nMaxX > nMaxDataX && !
aCol[nMaxX].GetLastVisibleAttr( nDummyRow ) )
702 nAttrStartX = nAttrEndX + 1;
712 SCCOL& rEndCol )
const
720 if (
aCol[
i].HasVisibleAttrIn( nStartRow, nEndRow ))
730 while ( nMaxX>0 &&
aCol[nMaxX].IsVisibleAttrEqual(
aCol[nMaxX+1], nStartRow, nEndRow) )
742 else if (
aCol[
i].HasSparklines())
757 SCROW& rEndRow,
bool bNotes )
const
759 nStartCol = std::min<SCCOL>( nStartCol,
aCol.
size()-1 );
760 nEndCol = std::min<SCCOL>( nEndCol,
aCol.
size()-1 );
765 for (
i=nStartCol;
i<=nEndCol;
i++)
768 if (
aCol[
i].GetLastVisibleAttr( nLastRow ))
771 if (nLastRow > nMaxY)
776 for (
i=nStartCol;
i<=nEndCol;
i++)
785 if (bNotes &&
aCol[
i].HasCellNotes() )
787 SCROW maxNoteRow =
aCol[
i].GetCellNotesMaxRow();
788 if (maxNoteRow > nMaxY)
794 if (
aCol[
i].HasSparklines())
796 SCROW maxNoteRow =
aCol[
i].GetSparklinesMaxRow();
797 if (maxNoteRow > nMaxY)
819 if (
aCol[
i].GetFirstVisibleAttr( nFirstRow ))
824 if (nFirstRow < nMinY)
839 bool bDatFound =
false;
844 if (!bDatFound &&
i<nMinX)
846 bFound = bDatFound =
true;
851 if (
aCol[
i].HasCellNotes() )
853 SCROW minNoteRow =
aCol[
i].GetCellNotesMinRow();
854 if (minNoteRow <= nMinY)
865 if (
aCol[
i].HasSparklines())
867 SCROW minSparkline =
aCol[
i].GetSparklinesMinRow();
868 if (minSparkline <= nMinY)
871 nMinY = minSparkline;
886 bool bIncludeOld,
bool bOnlyDown )
const
896 rStartCol = std::min<SCCOL>( rStartCol,
aCol.
size()-1 );
897 rEndCol = std::min<SCCOL>( rEndCol,
aCol.
size()-1 );
902 bool bBottom =
false;
903 bool bChanged =
false;
906 std::vector< sc::ColumnBlockConstPosition > blockPos( rEndCol + 1 );
907 for(
SCCOL i = 0;
i <= rEndCol; ++
i )
908 aCol[
i ].InitBlockPosition( blockPos[
i ] );
916 SCROW nStart = rStartRow;
917 SCROW nEnd = rEndRow;
918 if (nStart>0) --nStart;
924 assert(
int( blockPos.size()) == rEndCol + 1 );
926 blockPos.resize( blockPos.size() + 1 );
927 aCol[ rEndCol ].InitBlockPosition( blockPos[ rEndCol ] );
942 SCROW nTest = rStartRow-1;
943 bool needExtend =
false;
944 for (
SCCOL i = rStartCol;
i<=rEndCol && !needExtend;
i++)
945 if (
aCol[
i].HasDataAt(blockPos[
i], nTest))
958 SCROW nTest = rEndRow+1;
959 bool needExtend =
false;
960 for (
SCCOL i = rStartCol;
i<=rEndCol && !needExtend;
i++)
961 if (
aCol[
i].HasDataAt(blockPos[
i ], nTest))
973 if ( !bIncludeOld && !bOnlyDown )
976 while ( rStartCol < rEndCol && rStartCol < (
aCol.
size()-1) &&
aCol[rStartCol].IsEmptyData(rStartRow,rEndRow) )
980 while ( rEndCol > 0 && rStartCol < rEndCol &&
aCol[rEndCol].
IsEmptyData(rStartRow,rEndRow) )
988 for (
SCCOL i = rStartCol;
i<=rEndCol && bShrink;
i++)
989 if (
aCol[
i].HasDataAt(rStartRow))
993 }
while (bShrink && rStartRow <
rDocument.
MaxRow() && rStartRow < rEndRow);
999 if ( !bBottom && rEndRow > 0 && rStartRow < rEndRow )
1002 if (nLastDataRow < rEndRow)
1003 rEndRow = std::max( rStartRow, nLastDataRow);
1015 nCol2 = std::min<SCCOL>( nCol2,
aCol.
size()-1 );
1019 SCCOL nFirstNonEmptyCol = -1, nLastNonEmptyCol = -1;
1020 SCROW nRowStart = nRow2, nRowEnd = nRow1;
1022 for (
SCCOL nCol = nCol1; nCol <= nCol2; ++nCol )
1024 SCROW nRowStartThis = nRow1, nRowEndThis = nRow2;
1025 bool bTrimmed =
aCol[nCol].TrimEmptyBlocks(nRowStartThis, nRowEndThis);
1028 if ( nFirstNonEmptyCol == -1 )
1029 nFirstNonEmptyCol = nCol;
1030 nLastNonEmptyCol = nCol;
1032 nRowStart = std::min<SCROW>(nRowStart, nRowStartThis);
1033 nRowEnd = std::max<SCROW>(nRowEnd, nRowEndThis);
1037 if ( nFirstNonEmptyCol == -1 )
1040 assert(nFirstNonEmptyCol <= nLastNonEmptyCol);
1041 assert(nRowStart <= nRowEnd);
1050 SCCOL& rEndCol,
SCROW& rEndRow,
bool bColumnsOnly,
bool bStickyTopRow,
bool bStickyLeftCol,
1053 rStartCol = std::min<SCCOL>( rStartCol,
aCol.
size()-1 );
1081 while (rStartCol < rEndCol)
1085 if (pDataAreaExtras && pDataAreaExtras->
mnEndCol < rEndCol)
1089 &&
aCol[rEndCol].GetPatternCount( rStartRow, rEndRow) > 1
1090 &&
aCol[rEndCol].HasVisibleAttrIn( rStartRow, rEndRow)) ||
1092 && !
aCol[rEndCol].IsNotesEmptyBlock( rStartRow, rEndRow)) ||
1094 && !
aCol[rEndCol].IsDrawObjectsEmptyBlock( rStartRow, rEndRow)))
1095 pDataAreaExtras->
mnEndCol = rEndCol;
1105 if (!bStickyLeftCol)
1107 while (rStartCol < rEndCol)
1111 if (pDataAreaExtras && pDataAreaExtras->
mnStartCol > rStartCol)
1115 &&
aCol[rStartCol].GetPatternCount( rStartRow, rEndRow) > 1
1116 &&
aCol[rStartCol].HasVisibleAttrIn( rStartRow, rEndRow)) ||
1118 && !
aCol[rStartCol].IsNotesEmptyBlock( rStartRow, rEndRow)) ||
1120 && !
aCol[rStartCol].IsDrawObjectsEmptyBlock( rStartRow, rEndRow)))
1134 while (rStartRow < rEndRow)
1137 if (0 <= nLastDataRow && nLastDataRow < rEndRow)
1139 rEndRow = std::max( rStartRow, nLastDataRow);
1148 while (rStartRow < rEndRow)
1150 bool bFound =
false;
1151 for (
SCCOL i=rStartCol;
i<=rEndCol && !bFound;
i++)
1153 if (
aCol[
i].HasDataAt(rStartRow, pDataAreaExtras))
1167 return rStartCol != rEndCol || (bColumnsOnly ?
1168 !
aCol[rStartCol].IsEmptyData( rStartRow, rEndRow) :
1169 (rStartRow != rEndRow ||
1170 aCol[rStartCol].HasDataAt( rStartRow, pDataAreaExtras)));
1178 nCol2 = std::min<SCCOL>( nCol2,
aCol.
size() - 1 );
1180 SCROW nNewLastRow = 0;
1181 for (
SCCOL i = nCol1;
i <= nCol2; ++
i)
1183 SCROW nThis =
aCol[
i].GetLastDataPos(nLastRow, pDataAreaExtras);
1184 if (nNewLastRow < nThis)
1185 nNewLastRow = nThis;
1203 SCCOL nStartColOrig = nStartCol;
1204 SCCOL nEndColOrig = nEndCol;
1205 nStartCol = std::min<SCCOL>( nStartCol,
aCol.
size()-1 );
1206 nEndCol = std::min<SCCOL>( nEndCol,
aCol.
size()-1 );
1209 if ( nStartColOrig != nStartCol )
1211 static_cast<SCSIZE>(nEndRow - nStartRow + 1) :
1212 static_cast<SCSIZE>(nEndColOrig - nStartColOrig + 1) );
1214 SCSIZE nGapRight =
static_cast<SCSIZE>(nEndColOrig - nEndCol);
1220 for (nCol = nStartCol; nCol <= nEndCol; nCol++)
1226 while ((nCol >= nStartCol) &&
1227 aCol[nCol].IsEmptyData(nStartRow, nEndRow))
1237 while ((nCol <= nEndCol) &&
aCol[nCol].IsEmptyData(nStartRow, nEndRow))
1245 if ( nCol > nEndCol )
1257 nEndCol = std::min<SCCOL>( nEndCol,
aCol.
size()-1 );
1259 for (
SCCOL i=nStartCol;
i<=nEndCol;
i++)
1260 if (
aCol[
i].HasDataAt(nRow))
1267 rStartCol = std::min<SCCOL>( rStartCol,
aCol.
size()-1 );
1268 rEndCol = std::min<SCCOL>( rEndCol,
aCol.
size()-1 );
1270 while ( rStartCol<rEndCol &&
aCol[rStartCol].
IsEmptyData(rStartRow,rEndRow) )
1273 while ( rStartCol<rEndCol &&
aCol[rEndCol].
IsEmptyData(rStartRow,rEndRow) )
1276 while ( rStartRow<rEndRow &&
IsEmptyLine(rStartRow, rStartCol, rEndCol) )
1281 SCROW lastDataPos = 0;
1282 for (
SCCOL i=rStartCol;
i<=rEndCol;
i++)
1285 rEndRow = std::min(rEndRow, lastDataPos);
1287 rEndRow = std::max(rStartRow, rEndRow);
1310 return std::max<SCCOL>(0, nCol);
1321 if(nCol >= nLastCol)
1338 if(
aCol[nCol].HasVisibleDataAt(nRow))
1341 while(nCol < nLastCol);
1350 if ( nCol > nLastCol )
1363 nCol = nStartCol -1;
1368 if(
aCol[nCol].HasVisibleDataAt(nRow))
1383 SCCOL nNewCol = rCol;
1384 bool bThere = ( nNewCol <= nLastCol ) &&
aCol[nNewCol].HasVisibleDataAt(rRow);
1395 if( nNextCol <= nLastCol &&
aCol[nNextCol].HasVisibleDataAt(rRow) )
1397 bool bFound =
false;
1402 if( nNextCol <= nLastCol &&
aCol[nNextCol].HasVisibleDataAt(rRow) )
1427 if ( rCol <= nLastCol )
1440 bool bMarked,
bool bUnprotected )
const
1458 if (bMarked || bUnprotected)
1477 const bool bMarked,
const bool bSheetProtected )
const
1484 if ( rRow > nUsedY )
1499 if ( bRowHidden || bOverlapped )
1513 bool bMarked,
bool bUnprotected,
const ScMarkData& rMark,
SCCOL nTabStartCol )
const
1520 if ( bUnprotected && !bSheetProtected )
1521 bUnprotected =
false;
1523 SCCOL nCol = rCol + nMovX;
1524 SCROW nRow = rRow + nMovY;
1526 SCCOL nStartCol, nEndCol;
1527 SCROW nStartRow, nEndRow;
1550 else if (bUnprotected)
1578 rCol = nTabStartCol;
1583 if ( nMovY && (bMarked || bUnprotected))
1587 const bool bUp = (nMovY < 0);
1588 const SCCOL nColAdd = (bUp ? -1 : 1);
1609 nCol = nTabStartCol;
1613 while (
SkipRow( nCol, nRow, nMovY, rMark, bUp, nEndRow, bMarked, bSheetProtected ))
1616 sal_uInt16 nWrap = 0;
1617 while ( nRow < nStartRow || nRow > nEndRow )
1621 while (nStartCol <= nCol && nCol <= nEndCol &&
ValidCol(nCol) &&
ColHidden(nCol))
1624 if (nCol < nStartCol)
1631 else if (nCol > nEndCol)
1638 if (nRow < nStartRow)
1640 else if (nRow > nEndRow)
1646 while (
SkipRow( nCol, nRow, nMovY, rMark, bUp, nEndRow, bMarked, bSheetProtected ))
1652 if ( nMovX && ( bMarked || bUnprotected ) )
1655 if (nCol < nStartCol)
1659 if (nRow < nStartRow)
1670 if ( !
ValidNextPos(nCol, nRow, rMark, bMarked, bUnprotected) )
1672 const SCCOL nColCount = nEndCol - nStartCol + 1;
1673 std::unique_ptr<SCROW[]> pNextRows(
new SCROW[nColCount]);
1675 const bool bUp = (nMovX < 0);
1676 const SCROW nRowAdd = (bUp ? -1 : 1);
1677 sal_uInt16 nWrap = 0;
1681 for (
SCCOL i = 0;
i < nColCount; ++
i)
1682 pNextRows[
i] = (
i + nStartCol > nCol) ? (nRow + nRowAdd) : nRow;
1686 for (
SCCOL i = 0;
i < nColCount; ++
i)
1687 pNextRows[
i] = (
i + nStartCol < nCol) ? (nRow + nRowAdd) : nRow;
1691 SCROW nNextRow = pNextRows[nCol - nStartCol] + nRowAdd;
1695 nNextRow = ( nCol <= nLastCol ) ?
aCol[nCol].GetNextUnprotected( nNextRow, bUp ) :
1697 pNextRows[nCol - nStartCol] = nNextRow;
1701 SCROW nMaxRow = nStartRow - 1;
1702 for (
SCCOL i = 0;
i < nColCount; ++
i)
1704 if (pNextRows[
i] >= nMaxRow)
1706 nMaxRow = pNextRows[
i];
1707 nCol =
i + nStartCol;
1712 if ( nRow < nStartRow )
1718 for (
SCCOL i = 0;
i < nColCount; ++
i)
1719 pNextRows[
i] = nEndRow;
1724 SCROW nMinRow = nEndRow + 1;
1725 for (
SCCOL i = 0;
i < nColCount; ++
i)
1727 if (pNextRows[
i] < nMinRow)
1729 nMinRow = pNextRows[
i];
1730 nCol =
i + nStartCol;
1735 if ( nRow > nEndRow )
1741 for (
SCCOL i = 0;
i < nColCount; ++
i)
1742 pNextRows[
i] = nStartRow;
1746 while ( !
ValidNextPos(nCol, nRow, rMark, bMarked, bUnprotected) );
1772 std::pair<sc::CellStoreType::const_iterator,size_t> aPos = rCells.position(nStart);
1773 sc::CellStoreType::const_iterator it = aPos.first;
1774 SCROW nTestRow = nStart;
1778 nTestRow += it->
size - aPos.second;
1780 if (it == rCells.end())
1788 if (nTestRow <= nEnd)
1813 if ( !(
nTab >= nTab1 &&
nTab <= nTab2 && nDz == 0) )
1817 if ( eUpdateRefMode !=
URM_COPY && pDrawLayer )
1821 nCol1 = sal::static_int_cast<SCCOL>( nCol1 - nDx );
1822 nRow1 = sal::static_int_cast<SCROW>( nRow1 - nDy );
1823 nCol2 = sal::static_int_cast<SCCOL>( nCol2 - nDx );
1824 nRow2 = sal::static_int_cast<SCROW>( nRow2 - nDy );
1826 pDrawLayer->
MoveArea(
nTab, nCol1,nRow1, nCol2,nRow2, nDx,nDy,
1827 (eUpdateRefMode ==
URM_INSDEL), bUpdateNoteCaptionPos );
1834 bool bUpdated =
false;
1850 bUpdated |=
aCol[
col].UpdateReference(rCxt, pUndoDoc);
1855 bUpdated |=
aCol[
col].UpdateReference(rCxt, pUndoDoc);
1859 UpdateDrawRef( eUpdateRefMode, nCol1, nRow1, nTab1, nCol2, nRow2, nTab2, nDx, nDy, nDz, bUpdateNoteCaptionPos );
1861 if (
nTab >= nTab1 &&
nTab <= nTab2 && nDz == 0 )
1869 bool bRecalcPages =
false;
1873 nSCol = rPrintRange.aStart.Col();
1874 nSRow = rPrintRange.aStart.Row();
1875 nECol = rPrintRange.aEnd.Col();
1876 nERow = rPrintRange.aEnd.Row();
1880 nCol1,nRow1,
nTab, nCol2,nRow2,
nTab,
1882 nSCol,nSRow,nSTab, nECol,nERow,nETab ) )
1884 rPrintRange =
ScRange( nSCol, nSRow, 0, nECol, nERow, 0 );
1885 bRecalcPages =
true;
1898 nCol1,nRow1,
nTab, nCol2,nRow2,
nTab,
1900 nSCol,nSRow,nSTab, nECol,nERow,nETab ) )
1903 bRecalcPages =
true;
1918 nCol1,nRow1,
nTab, nCol2,nRow2,
nTab,
1920 nSCol,nSRow,nSTab, nECol,nERow,nETab ) )
1923 bRecalcPages =
true;
1951 for (
auto const & rpCol :
aCol)
1952 rpCol->UpdateTranspose( rSource, rDest, pUndoDoc );
1957 for (
auto const & rpCol :
aCol)
1958 rpCol->UpdateGrow( rArea, nGrowX, nGrowY );
2039 aCol[
i].UpdateMoveTab(rCxt, nTabNo);
2051 aCol[
i].UpdateCompile( bForceIfNameInUse );
2074 OSL_FAIL(
"ExtendPrintArea: No ColInfo or RowInfo");
2079 double nPPTX = aPix1000.X() / 1000.0;
2080 double nPPTY = aPix1000.Y() / 1000.0;
2097 for (
SCCOL j =
i; j <= nLastCol; ++j)
2113 for (
SCCOL nCol = rEndCol; nCol >= 0; --nCol)
2127 for (
SCCOL nDataCol = nCol; 0 <= nDataCol && nDataCol >= aColData.
mnCol1; --nDataCol)
2129 SCCOL nPrintCol = nDataCol;
2138 SCCOL nNewCol = nDataCol;
2145 if (nNewCol > nPrintCol)
2146 nPrintCol = nNewCol;
2147 aCell = aIter.
next();
2150 if (nPrintCol > rEndCol)
2152 rEndCol = nPrintCol;
2189 nRow, pDev,
nPPTX,
nPPTY, aZoom, aZoom,
true, aOptions,
nullptr );
2207 if ( eHorJust == SvxCellHorJustify::Center )
2212 bool bRight = ( eHorJust == SvxCellHorJustify::Right );
2220 SCCOL nNewCol = rCol;
2223 auto nNextCol = nNewCol + 1;
2224 bool bNextEmpty =
true;
2228 bNextEmpty = aNextCell.
isEmpty();
2247 explicit SetTableIndex(
SCTAB nTab) : mnTab(nTab) {}
2249 void operator() (
ScRange& rRange)
const
2357 mrRowSegs(rRowSegs),
2359 mnCurRow(ROW_NOT_FOUND),
2360 mnUBound(ROW_NOT_FOUND)
2366 if (nRow > mrDocument.MaxRow())
2368 mnCurRow = ROW_NOT_FOUND;
2373 if (!mrRowSegs.getRangeData(nRow,
aData))
2375 mnCurRow = ROW_NOT_FOUND;
2383 mnUBound =
aData.mnRow2;
2389 mnCurRow =
aData.mnRow2 + 1;
2390 mnUBound = mnCurRow;
2391 if (mnCurRow > mrDocument.MaxRow())
2394 mnCurRow = ROW_NOT_FOUND;
2399 maCell = mrColumn.GetCellValue(mnCurRow);
2400 if (!maCell.isEmpty())
2410 if (mnCurRow == ROW_NOT_FOUND)
2413 while (mrColumn.GetNextDataPos(mnCurRow))
2415 if (mnCurRow > mnUBound)
2419 if (!mrRowSegs.getRangeData(mnCurRow,
aData))
2421 mnCurRow = ROW_NOT_FOUND;
2429 mnCurRow = mnUBound =
aData.mnRow2;
2434 mnUBound =
aData.mnRow2;
2437 maCell = mrColumn.GetCellValue(mnCurRow);
2438 if (!maCell.isEmpty())
2442 mnCurRow = ROW_NOT_FOUND;
2458 pNew->SetKey(nMax+1);
2467 return SvtScriptType::NONE;
2469 return aCol[nCol].GetScriptType(nRow);
2484 return SvtScriptType::NONE;
2486 sc::CellStoreType::iterator itr =
aCol[nCol].maCells.
begin();
2497 return aCol[nCol].ResolveStaticReference(nRow);
2502 if (nCol2 < nCol1 || nRow2 < nRow1)
2515 for (
SCCOL nCol = nCol1; nCol <= nMaxCol; ++nCol)
2533 return aCol[nCol].FetchVectorRefArray(nRow1, nRow2);
2539 assert( nRow2 >= nRow1 );
2541 return aCol[nCol].AssertNoInterpretNeeded(nRow1, nRow2);
2558 return aCol[nCol].HandleRefArrayForParallelism(nRow1, nRow2, mxGroup);
2566 return aCol[nCol].GetCellValue(nRow);
2574 return aCol[nCol].GetCellValue(rBlockPos, nRow);
2582 return aCol[nCol].GetBroadcaster(nRow);
2591 aCol[nCol].DeleteBroadcasters(rBlockPos, nRow1, nRow2);
2597 col->DeleteEmptyBroadcasters();
2604 for (
SCCOL nCol = nCol1; nCol <= nCol2; ++nCol, ++nMatCol)
2611 for (
SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
2618 bool allInterpreted =
true;
2619 for (
SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
2621 allInterpreted =
false;
2622 return allInterpreted;
2630 aCol[nCol].SetFormulaResults(nRow, pResults, nLen);
2636 unsigned nThisThread,
unsigned nThreadsTotal)
2641 size_t nLen = nRowEnd - nRowStart + 1;
2643 for (
SCCOL nCurrCol = nColStart; nCurrCol <= nColEnd; ++nCurrCol)
2645 aCol[nCurrCol].CalculateInThread( rContext, nRowStart, nLen, nOffset, nThisThread, nThreadsTotal );
2655 for (
SCCOL nCurrCol = nColStart; nCurrCol <= nColEnd; ++nCurrCol)
2659#if DUMP_COLUMN_STORAGE
2665 aCol[nCol].DumpColumnStorage();
2674 return aCol[nCol].GetBroadcaster(nRow);
2703 if (nColEnd < nColBegin)
2705 assert( nColEnd >= 0 && nColEnd <=
GetDoc().MaxCol());
2723 if (nColEnd < nColBegin)
2725 assert( nColBegin >= 0 && nColBegin <=
GetDoc().MaxCol());
2726 assert( nColEnd >= 0 && nColEnd <=
GetDoc().MaxCol());
2739 for (
SCCOL i = aOldColSize;
i <= nScCol;
i++)
const SCROW SCROW_REPEAT_NONE
const SCCOL SCCOL_REPEAT_NONE
const SCCOL INITIALCOLCOUNT
const SCCOL SC_TABSTART_NONE
size_t SCSIZE
size_t typedef to be able to find places where code was changed from USHORT to size_t and is used to ...
void PutInOrder(T &nStart, T &nEnd)
OUString uppercase(const OUString &rStr, sal_Int32 nPos, sal_Int32 nCount) const
SAL_WARN_UNUSED_RESULT Point LogicToPixel(const Point &rLogicPt) const
void Set(SCCOL nCol, SCROW nRow, SCTAB nTab)
The data type represents bits, manageable by bitwise operations.
ScColumnVector::const_iterator begin() const
const ScColumn & back() const
void resize(ScSheetLimits const &, const size_t aNewSize)
void InitAttrArray(ScAttrArray *attrArray)
SCROW GetNextUnprotected(SCROW nRow, bool bUp) const
Including current, may return -1.
void GetOptimalHeight(sc::RowHeightContext &rCxt, SCROW nStartRow, SCROW nEndRow, sal_uInt16 nMinHeight, SCROW nMinStart)
sal_uInt64 GetWeightedCount() const
tools::Long GetNeededSize(SCROW nRow, OutputDevice *pDev, double nPPTX, double nPPTY, const Fraction &rZoomX, const Fraction &rZoomY, bool bWidth, const ScNeededSizeOptions &rOptions, const ScPatternAttr **pPatternChange, bool bInPrintTwips=false) const
ScRefCellValue GetCellValue(SCROW nRow) const
void SetTextWidth(SCROW nRow, sal_uInt16 nWidth)
sal_uInt16 GetTextWidth(SCROW nRow) const
RangeData GetRangeData(A nPos) const
Get range data for a row, i.e.
void SetValue(A nPos, const D &rValue)
const D & GetValue(A nPos) const
ScSheetLimits & GetSheetLimits() const
bool IsStreamValidLocked() const
SC_DLLPUBLIC SCCOL MaxCol() const
SC_DLLPUBLIC SCROW MaxRow() const
bool IsAdjustHeightLocked() const
void RepaintRange(const ScRange &rRange)
SC_DLLPUBLIC ScDrawLayer * GetDrawLayer()
SC_DLLPUBLIC bool HasAttrib(SCCOL nCol1, SCROW nRow1, SCTAB nTab1, SCCOL nCol2, SCROW nRow2, SCTAB nTab2, HasAttrFlags nMask) const
SfxObjectShell * GetDocumentShell() const
SC_DLLPUBLIC bool IsDocVisible() const
SC_DLLPUBLIC bool ColHidden(SCCOL nCol, SCTAB nTab, SCCOL *pFirstCol=nullptr, SCCOL *pLastCol=nullptr) const
bool IsInDtorClear() const
SC_DLLPUBLIC bool GetPrintArea(SCTAB nTab, SCCOL &rEndCol, SCROW &rEndRow, bool bNotes=true) const
SC_DLLPUBLIC const SfxItemSet * GetCondResult(SCCOL nCol, SCROW nRow, SCTAB nTab, ScRefCellValue *pCell=nullptr) const
void MoveArea(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, SCCOL nDx, SCROW nDy, bool bInsDel, bool bUpdateNoteCaptionPos)
void ScRenamePage(SCTAB nTab, const OUString &rNewName)
void SetPageSize(sal_uInt16 nPageNo, const Size &rSize, bool bUpdateNoteCaptionPos, const ScObjectHandling eObjectHandling=ScObjectHandling::RecalcPosMode)
bool ScAddPage(SCTAB nTab)
void ScRemovePage(SCTAB nTab)
bool setFalse(SCCOL nCol1, SCCOL nCol2)
bool setTrue(SCCOL nCol1, SCCOL nCol2)
bool getRangeData(SCCOL nCol, RangeData &rData)
static SC_DLLPUBLIC sal_uInt16 nStdRowHeight
static bool IsSystemRTL()
static SC_DLLPUBLIC const CharClass & getCharClass()
This is a rather odd datastructure.
SCROW GetNextMarked(SCROW nRow, bool bUp) const
Including current row, may return -1 if bUp and not found.
SCROW GetMarkEnd(SCROW nRow, bool bUp) const
todo: It should be possible to have MarkArrays for each table, in order to enable "search all" across...
const ScRange & GetMultiMarkArea() const
const ScRange & GetMarkArea() const
SCROW GetNextMarked(SCCOL nCol, SCROW nRow, bool bUp) const
May return -1.
bool IsMultiMarked() const
bool IsCellMarked(SCCOL nCol, SCROW nRow, bool bNoSimple=false) const
ScMarkArray GetMarkArray(SCCOL nCol) const
Matrix data type that can store values of mixed types.
const SfxPoolItem & GetItem(sal_uInt16 nWhichP) const
const std::optional< ScRange > & GetRepeatCol() const
bool IsEntireSheet() const
const std::optional< ScRange > & GetRepeatRow() const
const ScRangeVec & GetPrintRanges() const
void SetRepeat(std::optional< ScRange > oCol, std::optional< ScRange > oRow)
void SetAreas(ScRangeVec &&rRanges, bool bEntireSheet)
sal_uInt64 GetState() const
void SetState(sal_uInt64 nVal, sal_uInt64 nNewRange=0)
static ScRefUpdateRes Update(const ScDocument *pDoc, UpdateRefMode eUpdateRefMode, SCCOL nCol1, SCROW nRow1, SCTAB nTab1, SCCOL nCol2, SCROW nRow2, SCTAB nTab2, SCCOL nDx, SCROW nDy, SCTAB nDz, SCCOL &theCol1, SCROW &theRow1, SCTAB &theTab1, SCCOL &theCol2, SCROW &theRow2, SCTAB &theTab2)
Use this to iterate through non-empty visible cells in a single column.
VisibleDataCellIterator(const ScDocument &rDoc, ScFlatBoolRowSegments &rRowSegs, ScColumn &rColumn)
ScRefCellValue next()
Find the next visible data cell position.
SCROW getRow() const
Get the current row position.
ScRefCellValue reset(SCROW nRow)
Set the start row position.
std::unique_ptr< ScFlatBoolColSegments > mpHiddenCols
bool bTableAreaVisibleValid
bool ValidCol(SCCOL nCol) const
void UpdateInsertTab(sc::RefUpdateInsertTabContext &rCxt)
SCCOL FindNextVisibleCol(SCCOL nCol, bool bRight) const
void UpdateDrawRef(UpdateRefMode eUpdateRefMode, SCCOL nCol1, SCROW nRow1, SCTAB nTab1, SCCOL nCol2, SCROW nRow2, SCTAB nTab2, SCCOL nDx, SCROW nDy, SCTAB nDz, bool bUpdateNoteCaptionPos=true)
bool SkipRow(const SCCOL rCol, SCROW &rRow, const SCROW nMovY, const ScMarkData &rMark, const bool bUp, const SCROW nUsedY, const bool bMarked, const bool bSheetProtected) const
void FillMatrix(ScMatrix &rMat, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, svl::SharedStringPool *pPool) const
void AssertNoInterpretNeeded(SCCOL nCol, SCROW nRow1, SCROW nRow2)
std::unique_ptr< ScFlatBoolRowSegments > mpFilteredRows
ScRefCellValue GetRefCellValue(SCCOL nCol, SCROW nRow)
ScColumnsRange GetAllocatedColumnsRange(SCCOL begin, SCCOL end) const
const OUString & GetUpperName() const
void UpdateDeleteTab(sc::RefUpdateDeleteTabContext &rCxt)
void UpdateGrow(const ScRange &rArea, SCCOL nGrowX, SCROW nGrowY)
ScColumnsRange GetColumnsRange(SCCOL begin, SCCOL end) const
bool GetPrintAreaHor(SCROW nStartRow, SCROW nEndRow, SCCOL &rEndCol) const
bool GetCellArea(SCCOL &rEndCol, SCROW &rEndRow)
void SetLink(ScLinkMode nMode, const OUString &rDoc, const OUString &rFlt, const OUString &rOpt, const OUString &rTab, sal_uLong nRefreshDelay)
std::unique_ptr< ScDBData > pDBDataNoName
std::unique_ptr< ScConditionalFormatList > mpCondFormatList
void SetTabBgColor(const Color &rColor)
void InvalidatePageBreaks()
bool InterpretCellsIfNeeded(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2)
~ScTable() COVERITY_NOEXCEPT_FALSE
sal_uInt16 GetColWidth(SCCOL nCol, bool bHiddenAsZero=true) const
bool ValidColRow(SCCOL nCol, SCROW nRow) const
std::unique_ptr< ScBitMaskCompressedArray< SCROW, CRFlags > > pRowFlags
void SetLoadingRTL(bool bSet)
bool HandleRefArrayForParallelism(SCCOL nCol, SCROW nRow1, SCROW nRow2, const ScFormulaCellGroupRef &mxGroup)
void FillPrintSaver(ScPrintSaverTab &rSaveTab) const
ScColumn & CreateColumnIfNotExists(const SCCOL nScCol)
bool IsEmptyLine(SCROW nRow, SCCOL nStartCol, SCCOL nEndCol) const
bool GetDataStart(SCCOL &rStartCol, SCROW &rStartRow) const
bool IsColValid(const SCCOL nScCol) const
std::unique_ptr< ScBitMaskCompressedArray< SCCOL, CRFlags > > mpColFlags
void SetStreamValid(bool bSet, bool bIgnoreLock=false)
void GetDataArea(SCCOL &rStartCol, SCROW &rStartRow, SCCOL &rEndCol, SCROW &rEndRow, bool bIncludeOld, bool bOnlyDown) const
sal_uInt64 GetWeightedCount() const
sal_uLong nLinkRefreshDelay
void CalculateInColumnInThread(ScInterpreterContext &rContext, SCCOL nColStart, SCCOL nColEnd, SCROW nRowStart, SCROW nRowEnd, unsigned nThisThread, unsigned nThreadsTotal)
std::optional< ScRange > moRepeatRowRange
std::unique_ptr< ScFlatBoolColSegments > mpFilteredCols
void FindAreaPos(SCCOL &rCol, SCROW &rRow, ScMoveDirection eDirection) const
void SetCondFormList(ScConditionalFormatList *pList)
void RestorePrintRanges(const ScPrintSaverTab &rSaveTab)
void CreateColumnIfNotExistsImpl(const SCCOL nScCol)
void SetScriptType(SCCOL nCol, SCROW nRow, SvtScriptType nType)
void AddPrintRange(const ScRange &rNew)
Adds a new print ranges.
bool GetPrintArea(SCCOL &rEndCol, SCROW &rEndRow, bool bNotes, bool bCalcHiddens=false) const
void UpdateTranspose(const ScRange &rSource, const ScAddress &rDest, ScDocument *pUndoDoc)
void DeleteConditionalFormat(sal_uLong nOldIndex)
bool ColHidden(SCCOL nCol, SCCOL *pFirstCol=nullptr, SCCOL *pLastCol=nullptr) const
void UpdateReference(sc::RefUpdateContext &rCxt, ScDocument *pUndoDoc=nullptr, bool bIncludeDraw=true, bool bUpdateNoteCaptionPos=true)
std::unique_ptr< ScRangeList > pScenarioRanges
bool GetPrintAreaVer(SCCOL nStartCol, SCCOL nEndCol, SCROW &rEndRow, bool bNotes) const
std::unique_ptr< ScOutlineTable > pOutlineTable
sal_uInt16 GetPrintRangeCount() const
formula::VectorRefArray FetchVectorRefArray(SCCOL nCol, SCROW nRow1, SCROW nRow2)
void DumpColumnStorage(SCCOL nCol) const
void InterpretDirtyCells(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2)
void UpdateMoveTab(sc::RefUpdateMoveTabContext &rCxt, SCTAB nTabNo, ScProgress *pProgress)
void DestroySortCollator()
bool IsColRowValid(const SCCOL nScCol, const SCROW nScRow) const
void SetRepeatColRange(std::optional< ScRange > oNew)
void SetFormulaResults(SCCOL nCol, SCROW nRow, const double *pResults, size_t nLen)
void LimitChartArea(SCCOL &rStartCol, SCROW &rStartRow, SCCOL &rEndCol, SCROW &rEndRow) const
void MaybeAddExtraColumn(SCCOL &rCol, SCROW nRow, OutputDevice *pDev, double nPPTX, double nPPTY)
In case the cell text goes beyond the column width, move the max column position to the right.
void GetLastDataPos(SCCOL &rCol, SCROW &rRow) const
sal_uInt16 GetOptimalColWidth(SCCOL nCol, OutputDevice *pDev, double nPPTX, double nPPTY, const Fraction &rZoomX, const Fraction &rZoomY, bool bFormula, const ScMarkData *pMarkData, const ScColWidthParam *pParam)
bool GetTableArea(SCCOL &rEndCol, SCROW &rEndRow, bool bCalcHiddens=false) const
tools::Long GetNeededSize(SCCOL nCol, SCROW nRow, OutputDevice *pDev, double nPPTX, double nPPTY, const Fraction &rZoomX, const Fraction &rZoomY, bool bWidth, bool bTotalSize, bool bInPrintTwips=false)
void HandleStuffAfterParallelCalculation(SCCOL nColStart, SCCOL nColEnd, SCROW nRow, size_t nLen, ScInterpreter *pInterpreter)
ScTable(ScDocument &rDoc, SCTAB nNewTab, const OUString &rNewName, bool bColInfo=true, bool bRowInfo=true)
void UpdateCompile(bool bForceIfNameInUse=false)
ScColumnData aDefaultColData
ScColumnsRange GetWritableColumnsRange(SCCOL begin, SCCOL end)
ScConditionalFormatList * GetCondFormList()
bool SetRowHeightRange(SCROW nStartRow, SCROW nEndRow, sal_uInt16 nNewHeight, double nPPTY, bool bApi)
formula::FormulaTokenRef ResolveStaticReference(SCCOL nCol, SCROW nRow)
bool RowHidden(SCROW nRow, SCROW *pFirstRow=nullptr, SCROW *pLastRow=nullptr) const
bool IsEmptyData(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow) const
SCSIZE GetEmptyLinesInBlock(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, ScDirection eDir) const
void SetAnonymousDBData(std::unique_ptr< ScDBData > pDBData)
void SetPendingRowHeights(bool bSet)
std::unique_ptr< ScCompressedArray< SCCOL, sal_uInt16 > > mpColWidth
bool ShrinkToUsedDataArea(bool &o_bShrunk, SCCOL &rStartCol, SCROW &rStartRow, SCCOL &rEndCol, SCROW &rEndRow, bool bColumnsOnly, bool bStickyTopRow, bool bStickyLeftCol, ScDataAreaExtras *pDataAreaExtras) const
SCCOL GetAllocatedColumnsCount() const
void SetVisible(bool bVis)
sal_Int64 GetHashCode() const
bool GetDataAreaSubrange(ScRange &rRange) const
void SetOptimalHeightOnly(sc::RowHeightContext &rCxt, SCROW nStartRow, SCROW nEndRow, ScProgress *pOuterProgress=nullptr, sal_uInt64 nProgressStart=0)
void ExtendPrintArea(OutputDevice *pDev, SCCOL nStartCol, SCROW nStartRow, SCCOL &rEndCol, SCROW nEndRow)
void SetLayoutRTL(bool bSet)
sal_uLong AddCondFormat(std::unique_ptr< ScConditionalFormat > pNew)
void SetRowHeightOnly(SCROW nStartRow, SCROW nEndRow, sal_uInt16 nNewHeight)
Set specified row height to specified ranges.
void UpdatePageBreaks(const ScRange *pUserArea)
std::unique_ptr< ScFlatBoolRowSegments > mpHiddenRows
std::unique_ptr< ScFlatUInt16RowSegments > mpRowHeights
bool GetNextMarkedCell(SCCOL &rCol, SCROW &rRow, const ScMarkData &rMark) const
std::unique_ptr< ScRangeName > mpRangeName
SvtScriptType GetRangeScriptType(sc::ColumnBlockPosition &rBlockPos, SCCOL nCol, SCROW nRow1, SCROW nRow2)
SvtBroadcaster * GetBroadcaster(SCCOL nCol, SCROW nRow)
const ScPatternAttr * GetPattern(SCCOL nCol, SCROW nRow) const
bool SetOptimalHeight(sc::RowHeightContext &rCxt, SCROW nStartRow, SCROW nEndRow, bool bApi, ScProgress *pOuterProgress=nullptr, sal_uInt64 nProgressStart=0)
void FindRangeNamesInUse(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, sc::UpdatedRangeNames &rIndexes) const
void SetScenario(bool bFlag)
bool IsPrintEntireSheet() const
Returns true, if the sheet is always printed.
void CopyPrintRange(const ScTable &rTable)
void SetPrintEntireSheet()
Marks the specified sheet to be printed completely.
SCCOL ClampToAllocatedColumns(SCCOL nCol) const
sal_uInt64 GetCellCount() const
SCCOL FindNextVisibleColWithContent(SCCOL nCol, bool bRight, SCROW nRow) const
SvtScriptType GetScriptType(SCCOL nCol, SCROW nRow) const
bool ValidNextPos(SCCOL nCol, SCROW nRow, const ScMarkData &rMark, bool bMarked, bool bUnprotected) const
void GetNextPos(SCCOL &rCol, SCROW &rRow, SCCOL nMovX, SCROW nMovY, bool bMarked, bool bUnprotected, const ScMarkData &rMark, SCCOL nTabStartCol) const
SCROW GetLastDataRow(SCCOL nCol1, SCCOL nCol2, SCROW nLastRow, ScDataAreaExtras *pDataAreaExtras=nullptr) const
const ScRange * GetPrintRange(sal_uInt16 nPos) const
void SetName(const OUString &rNewName)
void DeleteBroadcasters(sc::ColumnBlockPosition &rBlockPos, SCCOL nCol, SCROW nRow1, SCROW nRow2)
std::unique_ptr< ScTableProtection > pTabProtection
std::optional< ScRange > moRepeatColRange
void SetTabNo(SCTAB nNewTab)
std::atomic< bool > bStreamValid
this is touched from formula group threading context
void DeleteEmptyBroadcasters()
std::unique_ptr< utl::TextSearch > pSearchText
void ClearPrintRanges()
Removes all print ranges.
std::unique_ptr< ScSheetEvents > pSheetEvents
bool ValidRow(SCROW nRow) const
void SetRepeatRowRange(std::optional< ScRange > oNew)
RowHeightsArray & getHeightArray()
sal_uInt16 getExtraHeight() const
bool isForceAutoSize() const
Keep track of all named expressions that have been updated during reference update.
constexpr ::Color COL_AUTO(ColorTransparency, 0xFF, 0xFF, 0xFF, 0xFF)
constexpr ::Color COL_LIGHTGRAY(0xC0, 0xC0, 0xC0)
constexpr sal_Int32 STD_EXTRA_WIDTH
constexpr sal_Int32 STD_COL_WIDTH
RttiCompleteObjectLocator col
constexpr OUStringLiteral aData
constexpr std::enable_if_t< std::is_signed_v< T >, std::make_unsigned_t< T > > make_unsigned(T value)
constexpr Point convert(const Point &rPoint, o3tl::Length eFrom, o3tl::Length eTo)
mdds::mtv::soa::multi_type_vector< CellStoreTraits > CellStoreType
Cell container.
const mdds::mtv::element_t element_type_empty
OUString ScResId(TranslateId aId)
constexpr TypedWhichId< SvxHorJustifyItem > ATTR_HOR_JUSTIFY(129)
This is very similar to ScCellValue, except that it references the original value instead of copying ...
Store position data for column array storage.
CellTextAttrStoreType::iterator miCellTextAttrPos
Context for reference update during shifting, moving or copying of cell ranges.
SCROW mnRowDelta
Amount and direction of movement in the row direction.
UpdateRefMode meMode
update mode - insert/delete, copy, or move.
SCCOL mnColDelta
Amount and direction of movement in the column direction.
SCTAB mnTabDelta
Amount and direction of movement in the sheet direction.
ScRange maRange
Range of cells that are about to be moved for insert/delete/move modes.
const SCCOL SC_COLUMNS_STOP
::boost::intrusive_ptr< ScFormulaCellGroup > ScFormulaCellGroupRef
::boost::intrusive_ptr< ScMatrix > ScMatrixRef