26 #include <osl/diagnose.h>
30 #include <document.hxx>
34 #include <globstr.hrc>
38 #include <progress.hxx>
66 if (nTotalCount < 1000)
75 return pOuterProgress;
84 void 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);
110 const SCROW nMinStart = nPos;
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 );
126 struct OptimalHeightsFuncObjBase
128 virtual ~OptimalHeightsFuncObjBase() {}
129 virtual bool operator() (
SCROW nStartRow,
SCROW nEndRow, sal_uInt16 nHeight,
bool bApi) = 0;
132 struct SetRowHeightOnlyFunc :
public OptimalHeightsFuncObjBase
135 explicit SetRowHeightOnlyFunc(
ScTable* pTab) :
139 virtual bool operator() (
SCROW nStartRow,
SCROW nEndRow, sal_uInt16 nHeight,
bool )
override
146 struct SetRowHeightRangeFunc :
public OptimalHeightsFuncObjBase
156 virtual bool operator() (
SCROW nStartRow,
SCROW nEndRow, sal_uInt16 nHeight,
bool bApi)
override
162 bool 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) ),
254 nTableAreaVisibleX( 0 ),
255 nTableAreaVisibleY( 0 ),
258 pSortCollator( nullptr ),
264 maLOKFreezeCell(-1, -1, nNewTab),
268 bPageSizeValid(false),
269 bTableAreaValid(false),
270 bTableAreaVisibleValid(false),
273 bPendingRowHeights(false),
274 bCalcNotification(false),
275 bGlobalKeepQuery(false),
276 bPrintEntireSheet(true),
277 bActiveScenario(false),
278 mbPageBreaksValid(false),
279 mbForceBreaks(false),
280 aDefaultColAttrArray(static_cast<
SCCOL>(-1), nNewTab, rDoc, nullptr)
323 aCol[nCol].FreeNotes();
348 return sal::static_int_cast<sal_Int64>(
reinterpret_cast<sal_IntPtr
>(
this));
413 const OUString& rDoc,
const OUString& rFlt,
const OUString& rOpt,
414 const OUString& rTab,
sal_uLong nRefreshDelay )
435 return aCol[nCol].GetOptimalColWidth( pDev, nPPTX, nPPTY, rZoomX, rZoomY,
443 bool bWidth,
bool bTotalSize,
bool bInPrintTwips )
452 return aCol[nCol].GetNeededSize
453 ( nRow, pDev, nPPTX, nPPTY, rZoomX, rZoomY, bWidth, aOptions,
nullptr, bInPrintTwips );
460 assert(nStartRow <= nEndRow);
463 "automatic OptimalHeight with Extra" );
470 SCSIZE nCount =
static_cast<SCSIZE>(nEndRow-nStartRow+1);
476 GetOptimalHeightsInColumn(rCxt,
aCol, nStartRow, nEndRow, pProgress, nProgressStart);
478 SetRowHeightRangeFunc aFunc(
this, rCxt.
getPPTY());
479 bool bChanged = SetOptimalHeightsToRows(rCxt, aFunc, pRowFlags.get(), nStartRow, nEndRow, bApi);
481 if ( pProgress != pOuterProgress )
494 "automatic OptimalHeight with Extra" );
499 SCSIZE nCount =
static_cast<SCSIZE>(nEndRow-nStartRow+1);
503 GetOptimalHeightsInColumn(rCxt,
aCol, nStartRow, nEndRow, pProgress, nProgressStart);
505 SetRowHeightOnlyFunc aFunc(
this);
507 SetOptimalHeightsToRows(rCxt, aFunc, pRowFlags.get(), nStartRow, nEndRow,
true);
509 if ( pProgress != pOuterProgress )
520 if (!
aCol[i].IsEmptyData())
528 if (
aCol[i].HasCellNotes() )
530 SCROW maxNoteRow =
aCol[i].GetCellNotesMaxRow();
531 if (maxNoteRow >= nMaxY)
588 if (!
aCol[i].IsEmptyData())
597 if (bNotes &&
aCol[i].HasCellNotes() )
599 SCROW maxNoteRow =
aCol[i].GetCellNotesMaxRow();
600 if (maxNoteRow >= nMaxY)
614 SCCOL nMaxDataX = nMaxX;
621 if (
aCol[i].GetLastVisibleAttr( nLastRow ))
625 if (nLastRow > nMaxY)
634 while ( nMaxX>0 &&
aCol[nMaxX].IsVisibleAttrEqual(
aCol[nMaxX+1]) )
638 if ( nMaxX < nMaxDataX )
642 else if ( nMaxX > nMaxDataX )
644 SCCOL nAttrStartX = nMaxDataX + 1;
645 while ( nAttrStartX < (
aCol.
size()-1) )
647 SCCOL nAttrEndX = nAttrStartX;
648 while ( nAttrEndX < (
aCol.
size()-1) &&
aCol[nAttrStartX].IsVisibleAttrEqual(
aCol[nAttrEndX+1]) )
650 if ( nAttrEndX + 1 - nAttrStartX >= SC_COLUMNS_STOP )
653 nMaxX = nAttrStartX - 1;
657 while ( nMaxX > nMaxDataX && !
aCol[nMaxX].GetLastVisibleAttr( nDummyRow ) )
661 nAttrStartX = nAttrEndX + 1;
671 SCCOL& rEndCol )
const
679 if (
aCol[i].HasVisibleAttrIn( nStartRow, nEndRow ))
689 while ( nMaxX>0 &&
aCol[nMaxX].IsVisibleAttrEqual(
aCol[nMaxX+1], nStartRow, nEndRow) )
695 if (!
aCol[i].IsEmptyBlock( nStartRow, nEndRow ))
708 SCROW& rEndRow,
bool bNotes )
const
710 nStartCol = std::min<SCCOL>( nStartCol,
aCol.
size()-1 );
711 nEndCol = std::min<SCCOL>( nEndCol,
aCol.
size()-1 );
716 for (i=nStartCol; i<=nEndCol; i++)
719 if (
aCol[i].GetLastVisibleAttr( nLastRow ))
722 if (nLastRow > nMaxY)
727 for (i=nStartCol; i<=nEndCol; i++)
729 if (!
aCol[i].IsEmptyData())
736 if (bNotes &&
aCol[i].HasCellNotes() )
738 SCROW maxNoteRow =
aCol[i].GetCellNotesMaxRow();
739 if (maxNoteRow > nMaxY)
761 if (
aCol[i].GetFirstVisibleAttr( nFirstRow ))
766 if (nFirstRow < nMinY)
776 while ( nMinX<(
aCol.
size()-1) &&
aCol[nMinX].IsVisibleAttrEqual(
aCol[nMinX-1]) )
781 bool bDatFound =
false;
784 if (!
aCol[i].IsEmptyData())
786 if (!bDatFound && i<nMinX)
788 bFound = bDatFound =
true;
793 if (
aCol[i].HasCellNotes() )
795 SCROW minNoteRow =
aCol[i].GetCellNotesMinRow();
796 if (minNoteRow <= nMinY)
814 bool bIncludeOld,
bool bOnlyDown )
const
824 rStartCol = std::min<SCCOL>( rStartCol,
aCol.
size()-1 );
825 rEndCol = std::min<SCCOL>( rEndCol,
aCol.
size()-1 );
830 bool bBottom =
false;
831 bool bChanged =
false;
834 std::vector< sc::ColumnBlockConstPosition > blockPos( rEndCol + 1 );
835 for(
SCCOL i = 0; i <= rEndCol; ++i )
836 aCol[ i ].InitBlockPosition( blockPos[ i ] );
844 SCROW nStart = rStartRow;
845 SCROW nEnd = rEndRow;
846 if (nStart>0) --nStart;
850 if (!
aCol[rEndCol+1].IsEmptyBlock(nStart,nEnd))
852 assert(
int( blockPos.size()) == rEndCol + 1 );
854 blockPos.resize( blockPos.size() + 1 );
855 aCol[ rEndCol ].InitBlockPosition( blockPos[ rEndCol ] );
861 if (!
aCol[rStartCol-1].IsEmptyBlock(nStart,nEnd))
870 SCROW nTest = rStartRow-1;
871 bool needExtend =
false;
872 for (
SCCOL i = rStartCol; i<=rEndCol && !needExtend; i++)
873 if (
aCol[i].HasDataAt(blockPos[i], nTest))
886 SCROW nTest = rEndRow+1;
887 bool needExtend =
false;
888 for (
SCCOL i = rStartCol; i<=rEndCol && !needExtend; i++)
889 if (
aCol[i].HasDataAt(blockPos[ i ], nTest))
901 if ( !bIncludeOld && !bOnlyDown )
904 while ( rStartCol < rEndCol && rStartCol < (
aCol.
size()-1) &&
aCol[rStartCol].IsEmptyBlock(rStartRow,rEndRow) )
908 while ( rEndCol > 0 && rStartCol < rEndCol &&
aCol[rEndCol].IsEmptyBlock(rStartRow,rEndRow) )
916 for (
SCCOL i = rStartCol; i<=rEndCol && bShrink; i++)
917 if (
aCol[i].HasDataAt(rStartRow))
921 }
while (bShrink && rStartRow <
rDocument.
MaxRow() && rStartRow < rEndRow);
927 if ( !bBottom && rEndRow > 0 && rStartRow < rEndRow )
930 if (nLastDataRow < rEndRow)
931 rEndRow = std::max( rStartRow, nLastDataRow);
943 nCol2 = std::min<SCCOL>( nCol2,
aCol.
size()-1 );
947 SCCOL nFirstNonEmptyCol = -1, nLastNonEmptyCol = -1;
948 SCROW nRowStart = nRow2, nRowEnd = nRow1;
950 for (
SCCOL nCol = nCol1; nCol <= nCol2; ++nCol )
952 SCROW nRowStartThis = nRow1, nRowEndThis = nRow2;
953 bool bTrimmed =
aCol[nCol].TrimEmptyBlocks(nRowStartThis, nRowEndThis);
956 if ( nFirstNonEmptyCol == -1 )
957 nFirstNonEmptyCol = nCol;
958 nLastNonEmptyCol = nCol;
960 nRowStart = std::min<SCROW>(nRowStart, nRowStartThis);
961 nRowEnd = std::max<SCROW>(nRowEnd, nRowEndThis);
965 if ( nFirstNonEmptyCol == -1 )
968 assert(nFirstNonEmptyCol <= nLastNonEmptyCol);
969 assert(nRowStart <= nRowEnd);
978 SCCOL& rEndCol,
SCROW& rEndRow,
bool bColumnsOnly,
bool bStickyTopRow,
bool bStickyLeftCol,
979 bool bConsiderCellNotes,
bool bConsiderCellDrawObjects,
bool bConsiderCellFormats )
const
981 rStartCol = std::min<SCCOL>( rStartCol,
aCol.
size()-1 );
1009 while (rStartCol < rEndCol)
1011 if (
aCol[rEndCol].IsEmptyBlock( rStartRow, rEndRow))
1013 if (bConsiderCellNotes && !
aCol[rEndCol].IsNotesEmptyBlock( rStartRow, rEndRow ))
1016 if (bConsiderCellDrawObjects && !
aCol[rEndCol].IsDrawObjectsEmptyBlock( rStartRow, rEndRow ))
1019 if (bConsiderCellFormats &&
aCol[rEndCol].HasVisibleAttrIn(rStartRow, rEndRow))
1029 if (!bStickyLeftCol)
1031 while (rStartCol < rEndCol)
1033 if (
aCol[rStartCol].IsEmptyBlock( rStartRow, rEndRow))
1035 if (bConsiderCellNotes && !
aCol[rStartCol].IsNotesEmptyBlock( rStartRow, rEndRow ))
1038 if (bConsiderCellDrawObjects && !
aCol[rStartCol].IsDrawObjectsEmptyBlock( rStartRow, rEndRow ))
1041 if (bConsiderCellFormats &&
aCol[rEndCol].HasVisibleAttrIn(rStartRow, rEndRow))
1056 while (rStartRow < rEndRow)
1058 bool bFound =
false;
1059 for (
SCCOL i=rStartCol; i<=rEndCol && !bFound; i++)
1061 if (
aCol[i].HasDataAt(rStartRow, bConsiderCellNotes, bConsiderCellDrawObjects,
1062 bConsiderCellFormats))
1075 while (rStartRow < rEndRow)
1078 bConsiderCellDrawObjects, bConsiderCellFormats);
1079 if (0 <= nLastDataRow && nLastDataRow < rEndRow)
1081 rEndRow = std::max( rStartRow, nLastDataRow);
1089 return rStartCol != rEndCol || (bColumnsOnly ?
1090 !
aCol[rStartCol].IsEmptyBlock( rStartRow, rEndRow) :
1091 (rStartRow != rEndRow ||
1092 aCol[rStartCol].HasDataAt( rStartRow, bConsiderCellNotes, bConsiderCellDrawObjects, bConsiderCellFormats )));
1096 bool bConsiderCellDrawObjects,
bool bConsiderCellFormats )
const
1101 nCol2 = std::min<SCCOL>( nCol2,
aCol.
size() - 1 );
1103 SCROW nNewLastRow = 0;
1104 for (
SCCOL i = nCol1; i <= nCol2; ++i)
1106 SCROW nThis =
aCol[i].GetLastDataPos(nLastRow, bConsiderCellNotes, bConsiderCellDrawObjects,
1107 bConsiderCellFormats);
1108 if (nNewLastRow < nThis)
1109 nNewLastRow = nThis;
1118 SCCOL nStartColOrig = nStartCol;
1119 SCCOL nEndColOrig = nEndCol;
1120 nStartCol = std::min<SCCOL>( nStartCol,
aCol.
size()-1 );
1121 nEndCol = std::min<SCCOL>( nEndCol,
aCol.
size()-1 );
1124 if ( nStartColOrig != nStartCol )
1126 static_cast<SCSIZE>(nEndRow - nStartRow + 1) :
1127 static_cast<SCSIZE>(nEndColOrig - nStartColOrig + 1) );
1129 SCSIZE nGapRight =
static_cast<SCSIZE>(nEndColOrig - nEndCol);
1134 nCount =
static_cast<SCSIZE>(nEndRow - nStartRow + 1);
1135 for (nCol = nStartCol; nCol <= nEndCol; nCol++)
1141 while ((nCol >= nStartCol) &&
1142 aCol[nCol].IsEmptyBlock(nStartRow, nEndRow))
1147 nCount += nGapRight;
1152 while ((nCol <= nEndCol) &&
aCol[nCol].IsEmptyBlock(nStartRow, nEndRow))
1160 if ( nCol > nEndCol )
1161 nCount += nGapRight;
1172 nEndCol = std::min<SCCOL>( nEndCol,
aCol.
size()-1 );
1174 bool bFound =
false;
1175 for (
SCCOL i=nStartCol; i<=nEndCol && !bFound; i++)
1176 if (
aCol[i].HasDataAt(nRow))
1183 rStartCol = std::min<SCCOL>( rStartCol,
aCol.
size()-1 );
1184 rEndCol = std::min<SCCOL>( rEndCol,
aCol.
size()-1 );
1186 while ( rStartCol<rEndCol &&
aCol[rStartCol].IsEmptyBlock(rStartRow,rEndRow) )
1189 while ( rStartCol<rEndCol &&
aCol[rEndCol].IsEmptyBlock(rStartRow,rEndRow) )
1192 while ( rStartRow<rEndRow &&
IsEmptyLine(rStartRow, rStartCol, rEndCol) )
1197 SCROW lastDataPos = 0;
1198 for (
SCCOL i=rStartCol; i<=rEndCol; i++)
1201 rEndRow = std::min(rEndRow, lastDataPos);
1203 rEndRow = std::max(rStartRow, rEndRow);
1226 return std::max<SCCOL>(0, nCol);
1237 if(nCol >= nLastCol)
1254 if(
aCol[nCol].HasVisibleDataAt(nRow))
1257 while(nCol < nLastCol);
1266 if ( nCol > nLastCol )
1279 nCol = nStartCol -1;
1284 if(
aCol[nCol].HasVisibleDataAt(nRow))
1299 SCCOL nNewCol = rCol;
1300 bool bThere = ( nNewCol <= nLastCol ) &&
aCol[nNewCol].HasVisibleDataAt(rRow);
1311 if( nNextCol <= nLastCol &&
aCol[nNextCol].HasVisibleDataAt(rRow) )
1313 bool bFound =
false;
1318 if( nNextCol <= nLastCol &&
aCol[nNextCol].HasVisibleDataAt(rRow) )
1343 if ( rCol <= nLastCol )
1356 bool bMarked,
bool bUnprotected )
const
1374 if (bMarked || bUnprotected)
1393 const bool bMarked,
const bool bSheetProtected )
const
1400 if ( rRow > nUsedY )
1415 if ( bRowHidden || bOverlapped )
1429 bool bMarked,
bool bUnprotected,
const ScMarkData& rMark,
SCCOL nTabStartCol )
const
1436 if ( bUnprotected && !bSheetProtected )
1437 bUnprotected =
false;
1439 SCCOL nCol = rCol + nMovX;
1440 SCROW nRow = rRow + nMovY;
1442 SCCOL nStartCol, nEndCol;
1443 SCROW nStartRow, nEndRow;
1466 else if (bUnprotected)
1494 rCol = nTabStartCol;
1499 if ( nMovY && (bMarked || bUnprotected))
1503 const bool bUp = (nMovY < 0);
1504 const SCCOL nColAdd = (bUp ? -1 : 1);
1525 nCol = nTabStartCol;
1529 while (
SkipRow( nCol, nRow, nMovY, rMark, bUp, nEndRow, bMarked, bSheetProtected ))
1532 sal_uInt16 nWrap = 0;
1533 while ( nRow < nStartRow || nRow > nEndRow )
1537 while (nStartCol <= nCol && nCol <= nEndCol &&
ValidCol(nCol) &&
ColHidden(nCol))
1540 if (nCol < nStartCol)
1547 else if (nCol > nEndCol)
1554 if (nRow < nStartRow)
1556 else if (nRow > nEndRow)
1562 while (
SkipRow( nCol, nRow, nMovY, rMark, bUp, nEndRow, bMarked, bSheetProtected ))
1568 if ( nMovX && ( bMarked || bUnprotected ) )
1571 if (nCol < nStartCol)
1575 if (nRow < nStartRow)
1586 if ( !
ValidNextPos(nCol, nRow, rMark, bMarked, bUnprotected) )
1588 const SCCOL nColCount = nEndCol - nStartCol + 1;
1589 std::unique_ptr<SCROW[]> pNextRows(
new SCROW[nColCount]);
1591 const bool bUp = (nMovX < 0);
1592 const SCROW nRowAdd = (bUp ? -1 : 1);
1593 sal_uInt16 nWrap = 0;
1597 for (
SCCOL i = 0; i < nColCount; ++i)
1598 pNextRows[i] = (i + nStartCol > nCol) ? (nRow + nRowAdd) : nRow;
1602 for (
SCCOL i = 0; i < nColCount; ++i)
1603 pNextRows[i] = (i + nStartCol < nCol) ? (nRow + nRowAdd) : nRow;
1607 SCROW nNextRow = pNextRows[nCol - nStartCol] + nRowAdd;
1611 nNextRow = ( nCol <= nLastCol ) ?
aCol[nCol].GetNextUnprotected( nNextRow, bUp ) :
1613 pNextRows[nCol - nStartCol] = nNextRow;
1617 SCROW nMaxRow = nStartRow - 1;
1618 for (
SCCOL i = 0; i < nColCount; ++i)
1620 if (pNextRows[i] >= nMaxRow)
1622 nMaxRow = pNextRows[i];
1623 nCol = i + nStartCol;
1628 if ( nRow < nStartRow )
1634 for (
SCCOL i = 0; i < nColCount; ++i)
1635 pNextRows[i] = nEndRow;
1640 SCROW nMinRow = nEndRow + 1;
1641 for (
SCCOL i = 0; i < nColCount; ++i)
1643 if (pNextRows[i] < nMinRow)
1645 nMinRow = pNextRows[i];
1646 nCol = i + nStartCol;
1651 if ( nRow > nEndRow )
1657 for (
SCCOL i = 0; i < nColCount; ++i)
1658 pNextRows[i] = nStartRow;
1662 while ( !
ValidNextPos(nCol, nRow, rMark, bMarked, bUnprotected) );
1685 SCROW nEnd = aArray.GetMarkEnd( nStart,
false );
1688 std::pair<sc::CellStoreType::const_iterator,size_t> aPos = rCells.position(nStart);
1689 sc::CellStoreType::const_iterator it = aPos.first;
1690 SCROW nTestRow = nStart;
1694 nTestRow += it->
size - aPos.second;
1696 if (it == rCells.end())
1704 if (nTestRow <= nEnd)
1729 if ( !(
nTab >= nTab1 &&
nTab <= nTab2 && nDz == 0) )
1733 if ( eUpdateRefMode !=
URM_COPY && pDrawLayer )
1737 nCol1 = sal::static_int_cast<
SCCOL>( nCol1 - nDx );
1738 nRow1 = sal::static_int_cast<
SCROW>( nRow1 - nDy );
1739 nCol2 = sal::static_int_cast<
SCCOL>( nCol2 - nDx );
1740 nRow2 = sal::static_int_cast<
SCROW>( nRow2 - nDy );
1742 pDrawLayer->
MoveArea(
nTab, nCol1,nRow1, nCol2,nRow2, nDx,nDy,
1743 (eUpdateRefMode ==
URM_INSDEL), bUpdateNoteCaptionPos );
1750 bool bUpdated =
false;
1776 for ( ; i<=iMax; i++)
1780 UpdateDrawRef( eUpdateRefMode, nCol1, nRow1, nTab1, nCol2, nRow2, nTab2, nDx, nDy, nDz, bUpdateNoteCaptionPos );
1782 if (
nTab >= nTab1 &&
nTab <= nTab2 && nDz == 0 )
1790 bool bRecalcPages =
false;
1794 nSCol = rPrintRange.aStart.Col();
1795 nSRow = rPrintRange.aStart.Row();
1796 nECol = rPrintRange.aEnd.Col();
1797 nERow = rPrintRange.aEnd.Row();
1801 nCol1,nRow1,
nTab, nCol2,nRow2,
nTab,
1803 nSCol,nSRow,nSTab, nECol,nERow,nETab ) )
1805 rPrintRange =
ScRange( nSCol, nSRow, 0, nECol, nERow, 0 );
1806 bRecalcPages =
true;
1819 nCol1,nRow1,
nTab, nCol2,nRow2,
nTab,
1821 nSCol,nSRow,nSTab, nECol,nERow,nETab ) )
1824 bRecalcPages =
true;
1839 nCol1,nRow1,
nTab, nCol2,nRow2,
nTab,
1841 nSCol,nSRow,nSTab, nECol,nERow,nETab ) )
1844 bRecalcPages =
true;
1872 for (
auto const & rpCol :
aCol)
1873 rpCol->UpdateTranspose( rSource, rDest, pUndoDoc );
1878 for (
auto const & rpCol :
aCol)
1879 rpCol->UpdateGrow( rArea, nGrowX, nGrowY );
1960 aCol[i].UpdateMoveTab(rCxt, nTabNo);
1972 aCol[i].UpdateCompile( bForceIfNameInUse );
1995 OSL_FAIL(
"ExtendPrintArea: No ColInfo or RowInfo");
2000 double nPPTX = aPix1000.X() / 1000.0;
2001 double nPPTY = aPix1000.Y() / 1000.0;
2013 aSkipCols.setTrue(i, nLastCol);
2018 for (
SCCOL j = i; j <= nLastCol; ++j)
2027 aSkipCols.setTrue(j,j);
2034 for (
SCCOL nCol = rEndCol; nCol >= 0; --nCol)
2036 if (!aSkipCols.getRangeData(nCol, aColData))
2048 for (
SCCOL nDataCol = nCol; 0 <= nDataCol && nDataCol >= aColData.
mnCol1; --nDataCol)
2050 SCCOL nPrintCol = nDataCol;
2059 SCCOL nNewCol = nDataCol;
2066 if (nNewCol > nPrintCol)
2067 nPrintCol = nNewCol;
2068 aCell = aIter.
next();
2071 if (nPrintCol > rEndCol)
2073 rEndCol = nPrintCol;
2110 nRow, pDev, nPPTX, nPPTY, aZoom, aZoom,
true, aOptions,
nullptr );
2112 rColumn.
SetTextWidth(nRow, static_cast<sal_uInt16>(nPixel));
2128 if ( eHorJust == SvxCellHorJustify::Center )
2133 bool bRight = ( eHorJust == SvxCellHorJustify::Right );
2141 SCCOL nNewCol = rCol;
2144 auto nNextCol = nNewCol + 1;
2145 bool bNextEmpty =
true;
2149 bNextEmpty = aNextCell.
isEmpty();
2168 explicit SetTableIndex(
SCTAB nTab) : mnTab(nTab) {}
2170 void operator() (
ScRange& rRange)
const
2280 mrRowSegs(rRowSegs),
2282 mnCurRow(ROW_NOT_FOUND),
2283 mnUBound(ROW_NOT_FOUND)
2293 if (nRow > mrDocument.MaxRow())
2295 mnCurRow = ROW_NOT_FOUND;
2300 if (!mrRowSegs.getRangeData(nRow, aData))
2302 mnCurRow = ROW_NOT_FOUND;
2316 mnCurRow = aData.
mnRow2 + 1;
2317 mnUBound = mnCurRow;
2318 if (mnCurRow > mrDocument.MaxRow())
2321 mnCurRow = ROW_NOT_FOUND;
2326 maCell = mrColumn.GetCellValue(mnCurRow);
2327 if (!maCell.isEmpty())
2337 if (mnCurRow == ROW_NOT_FOUND)
2340 while (mrColumn.GetNextDataPos(mnCurRow))
2342 if (mnCurRow > mnUBound)
2346 if (!mrRowSegs.getRangeData(mnCurRow, aData))
2348 mnCurRow = ROW_NOT_FOUND;
2356 mnCurRow = mnUBound = aData.
mnRow2;
2364 maCell = mrColumn.GetCellValue(mnCurRow);
2365 if (!maCell.isEmpty())
2369 mnCurRow = ROW_NOT_FOUND;
2385 pNew->SetKey(nMax+1);
2394 return SvtScriptType::NONE;
2396 return aCol[nCol].GetScriptType(nRow);
2404 aCol[nCol].SetScriptType(nRow, nType);
2411 return SvtScriptType::NONE;
2413 sc::CellStoreType::iterator itr =
aCol[nCol].maCells.
begin();
2422 return aCol[nCol].GetFormulaHash(nRow);
2430 return aCol[nCol].GetFormulaVectorState(nRow);
2440 return aCol[nCol].ResolveStaticReference(nRow);
2445 if (nCol2 < nCol1 || nRow2 < nRow1)
2458 for (
SCCOL nCol = nCol1; nCol <= nMaxCol; ++nCol)
2476 return aCol[nCol].FetchVectorRefArray(nRow1, nRow2);
2482 assert( nRow2 >= nRow1 );
2484 return aCol[nCol].AssertNoInterpretNeeded(nRow1, nRow2);
2501 return aCol[nCol].HandleRefArrayForParallelism(nRow1, nRow2, mxGroup);
2509 return aCol[nCol].GetCellValue(nRow);
2517 return aCol[nCol].GetCellValue(rBlockPos, nRow);
2525 return aCol[nCol].GetBroadcaster(nRow);
2534 aCol[nCol].DeleteBroadcasters(rBlockPos, nRow1, nRow2);
2540 for (
SCCOL nCol = nCol1; nCol <= nCol2; ++nCol, ++nMatCol)
2547 for (
SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
2556 aCol[nCol].SetFormulaResults(nRow, pResults, nLen);
2562 unsigned nThisThread,
unsigned nThreadsTotal)
2567 size_t nLen = nRowEnd - nRowStart + 1;
2569 for (
SCCOL nCurrCol = nColStart; nCurrCol <= nColEnd; ++nCurrCol)
2571 aCol[nCurrCol].CalculateInThread( rContext, nRowStart, nLen, nOffset, nThisThread, nThreadsTotal );
2581 for (
SCCOL nCurrCol = nColStart; nCurrCol <= nColEnd; ++nCurrCol)
2585 #if DUMP_COLUMN_STORAGE
2591 aCol[nCol].DumpColumnStorage();
2600 return aCol[nCol].GetBroadcaster(nRow);
2628 ScColContainer::ScColumnVector::const_iterator beginIter;
2629 ScColContainer::ScColumnVector::const_iterator endIter;
2632 if (nColEnd < nColBegin)
2662 for (
SCCOL i = aOldColSize; i <= nScCol; i++)
formula::FormulaTokenRef ResolveStaticReference(SCCOL nCol, SCROW nRow)
static bool IsSystemRTL()
SC_DLLPUBLIC bool GetPrintArea(SCTAB nTab, SCCOL &rEndCol, SCROW &rEndRow, bool bNotes=true) const
Matrix data type that can store values of mixed types.
SCROW GetNextMarked(SCCOL nCol, SCROW nRow, bool bUp) const
May return -1.
SCROW mnRowDelta
Amount and direction of movement in the row direction.
const ScPatternAttr * GetPattern(SCCOL nCol, SCROW nRow) const
void UpdatePageBreaks(const ScRange *pUserArea)
sal_Int64 GetHashCode() const
sal_uLong GetWeightedCount() const
bool SetRowHeightRange(SCROW nStartRow, SCROW nEndRow, sal_uInt16 nNewHeight, double nPPTY, bool bApi)
::boost::intrusive_ptr< ScFormulaCellGroup > ScFormulaCellGroupRef
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)
void SetTextWidth(SCROW nRow, sal_uInt16 nWidth)
bool isForceAutoSize() const
todo: It should be possible to have MarkArrays for each table, in order to enable "search all" across...
sal_uLong GetWeightedCount() const
~ScTable() COVERITY_NOEXCEPT_FALSE
void SetLink(ScLinkMode nMode, const OUString &rDoc, const OUString &rFlt, const OUString &rOpt, const OUString &rTab, sal_uLong nRefreshDelay)
void DeleteConditionalFormat(sal_uLong nOldIndex)
void DestroySortCollator()
std::unique_ptr< ScFlatUInt16RowSegments > mpRowHeights
const ScRange * GetPrintRange(sal_uInt16 nPos) const
void UpdateGrow(const ScRange &rArea, SCCOL nGrowX, SCROW nGrowY)
SCCOL FindNextVisibleColWithContent(SCCOL nCol, bool bRight, SCROW nRow) const
void SetName(const OUString &rNewName)
bool GetPrintArea(SCCOL &rEndCol, SCROW &rEndRow, bool bNotes, bool bCalcHiddens=false) const
CellTextAttrStoreType::iterator miCellTextAttrPos
void SetRowHeightOnly(SCROW nStartRow, SCROW nEndRow, sal_uInt16 nNewHeight)
Set specified row height to specified ranges.
void SetScenario(bool bFlag)
sal_uInt16 getExtraHeight() const
void InterpretDirtyCells(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2)
void SetScriptType(SCCOL nCol, SCROW nRow, SvtScriptType nType)
sal_uInt16 GetPrintRangeCount() const
void SetPrintEntireSheet()
Marks the specified sheet to be printed completely.
Context for reference update during shifting, moving or copying of cell ranges.
SvtScriptType GetScriptType(SCCOL nCol, SCROW nRow) const
constexpr::Color COL_AUTO(ColorTransparency, 0xFF, 0xFF, 0xFF, 0xFF)
SCCOL FindNextVisibleCol(SCCOL nCol, bool bRight) const
bool GetPrintAreaVer(SCCOL nStartCol, SCCOL nEndCol, SCROW &rEndRow, bool bNotes) const
std::unique_ptr< ScFlatBoolColSegments > mpFilteredCols
ScColumnVector::const_iterator end() const
ScRefCellValue reset(SCROW nRow)
Set the start row position.
SCROW getRow() const
Get the current row position.
void SetFormulaResults(SCCOL nCol, SCROW nRow, const double *pResults, size_t nLen)
Store position data for column array storage.
ScFormulaVectorState GetFormulaVectorState(SCCOL nCol, SCROW nRow) const
This is very similar to ScCellValue, except that it references the original value instead of copying ...
void UpdateReference(sc::RefUpdateContext &rCxt, ScDocument *pUndoDoc=nullptr, bool bIncludeDraw=true, bool bUpdateNoteCaptionPos=true)
constexpr::Color COL_LIGHTGRAY(0xC0, 0xC0, 0xC0)
RowHeightsArray & getHeightArray()
void SetLoadingRTL(bool bSet)
mdds::multi_type_vector< CellFunc, CellStoreEvent > CellStoreType
SC_DLLPUBLIC bool HasAttrib(SCCOL nCol1, SCROW nRow1, SCTAB nTab1, SCCOL nCol2, SCROW nRow2, SCTAB nTab2, HasAttrFlags nMask) const
void LimitChartArea(SCCOL &rStartCol, SCROW &rStartRow, SCCOL &rEndCol, SCROW &rEndRow) const
std::unique_ptr< ScRangeName > mpRangeName
bool IsAdjustHeightLocked() const
void MoveArea(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, SCCOL nDx, SCROW nDy, bool bInsDel, bool bUpdateNoteCaptionPos)
bool bTableAreaVisibleValid
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 SetRepeatColRange(std::unique_ptr< ScRange > pNew)
bool IsCellMarked(SCCOL nCol, SCROW nRow, bool bNoSimple=false) const
void FillPrintSaver(ScPrintSaverTab &rSaveTab) const
bool ValidRow(SCROW nRow) const
void GetMarkArea(ScRange &rRange) const
void SetStreamValid(bool bSet, bool bIgnoreLock=false)
ScColumn & CreateColumnIfNotExists(const SCCOL nScCol) const
void CalculateInColumnInThread(ScInterpreterContext &rContext, SCCOL nColStart, SCCOL nColEnd, SCROW nRowStart, SCROW nRowEnd, unsigned nThisThread, unsigned nThreadsTotal)
void RepaintRange(const ScRange &rRange)
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)
ScRefCellValue GetCellValue(SCROW nRow) const
bool ValidNextPos(SCCOL nCol, SCROW nRow, const ScMarkData &rMark, bool bMarked, bool bUnprotected) const
SC_DLLPUBLIC SCROW MaxRow() const
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 SetAnonymousDBData(std::unique_ptr< ScDBData > pDBData)
const BorderLinePrimitive2D *pCandidateB assert(pCandidateA)
This is a rather odd datastructure.
void FillMatrix(ScMatrix &rMat, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, svl::SharedStringPool *pPool) const
bool IsMultiMarked() const
void ClearPrintRanges()
Removes all print ranges.
SC_DLLPUBLIC bool IsDocVisible() const
const ScRange * GetRepeatRow() const
bool setFalse(SCCOL nCol1, SCCOL nCol2)
::boost::intrusive_ptr< ScMatrix > ScMatrixRef
void HandleStuffAfterParallelCalculation(SCCOL nColStart, SCCOL nColEnd, SCROW nRow, size_t nLen, ScInterpreter *pInterpreter)
ScRefCellValue next()
Find the next visible data cell position.
ScColumnVector::const_iterator begin() const
void SetPendingRowHeights(bool bSet)
void FindAreaPos(SCCOL &rCol, SCROW &rRow, ScMoveDirection eDirection) const
std::unique_ptr< ScOutlineTable > pOutlineTable
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 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
std::unique_ptr< ScBitMaskCompressedArray< SCCOL, CRFlags > > mpColFlags
constexpr auto convert(N n, sal_Int64 mul, sal_Int64 div)
void SetRepeatRowRange(std::unique_ptr< ScRange > pNew)
VisibleDataCellIterator(const ScDocument &rDoc, ScFlatBoolRowSegments &rRowSegs, ScColumn &rColumn)
const SfxPoolItem & GetItem(sal_uInt16 nWhichP) const
void PutInOrder(T &nStart, T &nEnd)
std::unique_ptr< utl::TextSearch > pSearchText
bool IsColValid(const SCCOL nScCol) const
constexpr OUStringLiteral aData
void SetRepeat(const ScRange *pCol, const ScRange *pRow)
bool UpdateReference(sc::RefUpdateContext &rCxt, ScDocument *pUndoDoc)
Update reference addresses in formula cell in response to mass cell movement.
static SC_DLLPUBLIC sal_uInt16 nStdRowHeight
std::unique_ptr< ScFlatBoolColSegments > mpHiddenCols
SCSIZE GetEmptyLinesInBlock(SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow, ScDirection eDir) const
SC_DLLPUBLIC ScDrawLayer * GetDrawLayer()
bool ShrinkToUsedDataArea(bool &o_bShrunk, SCCOL &rStartCol, SCROW &rStartRow, SCCOL &rEndCol, SCROW &rEndRow, bool bColumnsOnly, bool bStickyTopRow, bool bStickyLeftCol, bool bConsiderCellNotes, bool bConsiderCellDrawObjects, bool bConsiderCellPatterns) const
SC_DLLPUBLIC SCCOL MaxCol() const
bool ColHidden(SCCOL nCol, SCCOL *pFirstCol=nullptr, SCCOL *pLastCol=nullptr) const
SC_DLLPUBLIC bool ColHidden(SCCOL nCol, SCTAB nTab, SCCOL *pFirstCol=nullptr, SCCOL *pLastCol=nullptr) const
bool ValidCol(SCCOL nCol) const
Keep track of all named expressions that have been updated during reference update.
void AssertNoInterpretNeeded(SCCOL nCol, SCROW nRow1, SCROW nRow2)
void FillMatrix(ScMatrix &rMat, size_t nMatCol, SCROW nRow1, SCROW nRow2, svl::SharedStringPool *pPool) const
void SetOptimalHeightOnly(sc::RowHeightContext &rCxt, SCROW nStartRow, SCROW nEndRow, ScProgress *pOuterProgress=nullptr, sal_uLong nProgressStart=0)
void FindRangeNamesInUse(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, sc::UpdatedRangeNames &rIndexes) const
std::unique_ptr< ScRange > pRepeatColRange
UpdateRefMode meMode
update mode - insert/delete, copy, or move.
void Set(SCCOL nCol, SCROW nRow, SCTAB nTab)
void RestorePrintRanges(const ScPrintSaverTab &rSaveTab)
void UpdateInsertTab(sc::RefUpdateInsertTabContext &rCxt)
sal_uInt16 GetColWidth(SCCOL nCol, bool bHiddenAsZero=true) const
bool GetPrintAreaHor(SCROW nStartRow, SCROW nEndRow, SCCOL &rEndCol) const
std::unique_ptr< ScDBData > pDBDataNoName
void CreateColumnIfNotExistsImpl(const SCCOL nScCol) const
ScSheetLimits & GetSheetLimits() const
void UpdateCompile(bool bForceIfNameInUse=false)
void AddPrintRange(const ScRange &rNew)
Adds a new print ranges.
constexpr std::enable_if_t< std::is_signed_v< T >, std::make_unsigned_t< T > > make_unsigned(T value)
const mdds::mtv::element_t element_type_empty
std::unique_ptr< ScTableProtection > pTabProtection
OUString uppercase(const OUString &rStr, sal_Int32 nPos, sal_Int32 nCount) const
bool ScAddPage(SCTAB nTab)
ScMarkArray GetMarkArray(SCCOL nCol) const
ScRefCellValue GetRefCellValue(SCCOL nCol, SCROW nRow)
void GetLastDataPos(SCCOL &rCol, SCROW &rRow) const
OUString ScResId(const char *pId)
~VisibleDataCellIterator()
const ScRangeVec & GetPrintRanges() const
bool GetNextMarkedCell(SCCOL &rCol, SCROW &rRow, const ScMarkData &rMark) const
sal_uLong GetState() const
bool GetTableArea(SCCOL &rEndCol, SCROW &rEndRow, bool bCalcHiddens=false) const
size_t GetFormulaHash(SCCOL nCol, SCROW nRow) const
std::unique_ptr< ScConditionalFormatList > mpCondFormatList
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
SvtScriptType GetRangeScriptType(sc::ColumnBlockPosition &rBlockPos, SCCOL nCol, SCROW nRow1, SCROW nRow2)
void UpdateTranspose(const ScRange &rSource, const ScAddress &rDest, ScDocument *pUndoDoc)
const SCCOL SC_COLUMNS_STOP
void SetValue(A nPos, const D &rValue)
const ScRange * GetRepeatCol() const
SC_DLLPUBLIC const SfxItemSet * GetCondResult(SCCOL nCol, SCROW nRow, SCTAB nTab, ScRefCellValue *pCell=nullptr) const
void SetTabNo(SCTAB nNewTab)
ScTable(ScDocument &rDoc, SCTAB nNewTab, const OUString &rNewName, bool bColInfo=true, bool bRowInfo=true)
ScRange maRange
Range of cells that are about to be moved for insert/delete/move modes.
const SCROW SCROW_REPEAT_NONE
bool IsEmptyLine(SCROW nRow, SCCOL nStartCol, SCCOL nEndCol) const
void SetCondFormList(ScConditionalFormatList *pList)
void UpdateMoveTab(sc::RefUpdateMoveTabContext &rCxt, SCTAB nTabNo, ScProgress *pProgress)
Point LogicToPixel(const Point &rLogicPt) const
bool GetDataAreaSubrange(ScRange &rRange) const
void UpdateDeleteTab(sc::RefUpdateDeleteTabContext &rCxt)
const D & GetValue(A nPos) const
void InvalidatePageBreaks()
void GetOptimalHeight(sc::RowHeightContext &rCxt, SCROW nStartRow, SCROW nEndRow, sal_uInt16 nMinHeight, SCROW nMinStart)
bool IsInDtorClear() const
void SetState(sal_uLong nVal, sal_uLong nNewRange=0)
bool RowHidden(SCROW nRow, SCROW *pFirstRow=nullptr, SCROW *pLastRow=nullptr) 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 SetPageSize(sal_uInt16 nPageNo, const Size &rSize, bool bUpdateNoteCaptionPos, const ScObjectHandling eObjectHandling=ScObjectHandling::RecalcPosMode)
void SetTabBgColor(const Color &rColor)
bool IsColRowValid(const SCCOL nScCol, const SCROW nScRow) const
bool IsPrintEntireSheet() const
Returns true, if the sheet is always printed.
std::unique_ptr< ScFlatBoolRowSegments > mpFilteredRows
void ScRenamePage(SCTAB nTab, const OUString &rNewName)
const SCCOL INITIALCOLCOUNT
bool IsEntireSheet() const
void GetDataArea(SCCOL &rStartCol, SCROW &rStartRow, SCCOL &rEndCol, SCROW &rEndRow, bool bIncludeOld, bool bOnlyDown) const
SCROW GetLastDataRow(SCCOL nCol1, SCCOL nCol2, SCROW nLastRow, bool bConsiderCellNotes=false, bool bConsiderCellDrawObjects=false, bool bConsiderCellPatterns=false) const
bool ValidColRow(SCCOL nCol, SCROW nRow) const
SCTAB mnTabDelta
Amount and direction of movement in the sheet direction.
void SetLayoutRTL(bool bSet)
RangeData GetRangeData(A nPos) const
Get range data for a row, i.e.
sal_uLong GetCellCount() const
void DumpColumnStorage(SCCOL nCol) const
ScColumnsRange GetColumnsRange(SCCOL begin, SCCOL end) const
bool GetCellArea(SCCOL &rEndCol, SCROW &rEndRow) const
void DeleteBroadcasters(sc::ColumnBlockPosition &rBlockPos, SCCOL nCol, SCROW nRow1, SCROW nRow2)
void SetVisible(bool bVis)
formula::VectorRefArray FetchVectorRefArray(SCCOL nCol, SCROW nRow1, SCROW nRow2)
std::unique_ptr< ScCompressedArray< SCCOL, sal_uInt16 > > mpColWidth
constexpr TypedWhichId< SvxHorJustifyItem > ATTR_HOR_JUSTIFY(129)
bool HandleRefArrayForParallelism(SCCOL nCol, SCROW nRow1, SCROW nRow2, const ScFormulaCellGroupRef &mxGroup)
static SC_DLLPUBLIC const CharClass * getCharClassPtr()
SvtBroadcaster * GetBroadcaster(SCCOL nCol, SCROW nRow)
SCROW GetNextUnprotected(SCROW nRow, bool bUp) const
Including current, may return -1.
const ScColumn & back() const
void CopyPrintRange(const ScTable &rTable)
std::unique_ptr< ScRange > pRepeatRowRange
std::unique_ptr< ScRangeList > pScenarioRanges
SfxObjectShell * GetDocumentShell() const
The data type represents bits, manageable by bitwise operations.
ScFormulaVectorState
When vectorization is enabled, we could potentially mass-calculate a series of formula token arrays i...
const SCCOL SC_TABSTART_NONE
void GetMultiMarkArea(ScRange &rRange) const
SCCOL ClampToAllocatedColumns(SCCOL nCol) const
void resize(ScSheetLimits const &, const size_t aNewSize)
bool SetOptimalHeight(sc::RowHeightContext &rCxt, SCROW nStartRow, SCROW nEndRow, bool bApi, ScProgress *pOuterProgress=nullptr, sal_uLong nProgressStart=0)
sal_uLong AddCondFormat(std::unique_ptr< ScConditionalFormat > pNew)
void GetNextPos(SCCOL &rCol, SCROW &rRow, SCCOL nMovX, SCROW nMovY, bool bMarked, bool bUnprotected, const ScMarkData &rMark, SCCOL nTabStartCol) const
SCCOL mnColDelta
Amount and direction of movement in the column direction.
std::unique_ptr< ScFlatBoolRowSegments > mpHiddenRows
sal_uInt16 GetTextWidth(SCROW nRow) const
SCCOL GetAllocatedColumnsCount() const
const OUString & GetUpperName() const
std::unique_ptr< ScSheetEvents > pSheetEvents
void ExtendPrintArea(OutputDevice *pDev, SCCOL nStartCol, SCROW nStartRow, SCCOL &rEndCol, SCROW nEndRow)
void ScRemovePage(SCTAB nTab)
ScAttrArray aDefaultColAttrArray
SCROW GetNextMarked(SCROW nRow, bool bUp) const
Including current row, may return -1 if bUp and not found.
bool IsStreamValidLocked() const
sal_uLong nLinkRefreshDelay
const SCCOL SCCOL_REPEAT_NONE
Use this to iterate through non-empty visible cells in a single column.
void SetAreas(const ScRangeVec &rRanges, bool bEntireSheet)
bool GetDataStart(SCCOL &rStartCol, SCROW &rStartRow) const
ScConditionalFormatList * GetCondFormList()