sc: rowcol: tdf#50916 convert core/data/table*

Change-Id: I7b1c5f76000a55519785b6612ab1949d47dc53d4
Reviewed-on: https://gerrit.libreoffice.org/82510
Tested-by: Jenkins
Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>

8 files changed, 158 insertions, 156 deletions

diff --git a/sc/inc/table.hxx b/sc/inc/table.hxx
index 4126d4640942..823b3f7bafde 100644
--- a/sc/inc/table.hxx
+++ b/sc/inc/table.hxx
@@ -1242,7 +1242,7 @@ private:
         static constexpr SCROW ROW_NOT_FOUND = -1;
 
     public:
-        explicit VisibleDataCellIterator(ScFlatBoolRowSegments& rRowSegs, ScColumn& rColumn);
+        explicit VisibleDataCellIterator(const ScDocument* pDoc, ScFlatBoolRowSegments& rRowSegs, ScColumn& rColumn);
         ~VisibleDataCellIterator();
 
         /**
@@ -1270,6 +1270,7 @@ private:
         SCROW getRow() const { return mnCurRow;}
 
     private:
+        const ScDocument* mpDocument;
         ScFlatBoolRowSegments& mrRowSegs;
         ScColumn& mrColumn;
         ScRefCellValue maCell;
diff --git a/sc/source/core/data/table1.cxx b/sc/source/core/data/table1.cxx
index 84c4210775c4..a7f8991c0276 100644
--- a/sc/source/core/data/table1.cxx
+++ b/sc/source/core/data/table1.cxx
@@ -273,14 +273,14 @@ ScTable::ScTable( ScDocument* pDoc, SCTAB nNewTab, const OUString& rNewName,
 {
     if (bColInfo)
     {
-        mpColWidth.reset( new ScCompressedArray<SCCOL, sal_uInt16>( MAXCOL+1, STD_COL_WIDTH ) );
-        mpColFlags.reset( new ScBitMaskCompressedArray<SCCOL, CRFlags>( MAXCOL+1, CRFlags::NONE ) );
+        mpColWidth.reset( new ScCompressedArray<SCCOL, sal_uInt16>( pDocument->MaxCol()+1, STD_COL_WIDTH ) );
+        mpColFlags.reset( new ScBitMaskCompressedArray<SCCOL, CRFlags>( pDocument->MaxCol()+1, CRFlags::NONE ) );
     }
 
     if (bRowInfo)
     {
         mpRowHeights.reset(new ScFlatUInt16RowSegments(ScGlobal::nStdRowHeight));
-        pRowFlags.reset(new ScBitMaskCompressedArray<SCROW, CRFlags>( MAXROW, CRFlags::NONE));
+        pRowFlags.reset(new ScBitMaskCompressedArray<SCROW, CRFlags>( pDocument->MaxRow(), CRFlags::NONE));
     }
 
     if ( pDocument->IsDocVisible() )
@@ -296,8 +296,8 @@ ScTable::ScTable( ScDocument* pDoc, SCTAB nNewTab, const OUString& rNewName,
         if ( pDrawLayer->ScAddPage( nTab ) )    // sal_False (not inserted) during Undo
         {
             pDrawLayer->ScRenamePage( nTab, aName );
-            sal_uLong const nx = sal_uLong(double(MAXCOL+1) * STD_COL_WIDTH           * HMM_PER_TWIPS );
-            sal_uLong ny = static_cast<sal_uLong>(double(MAXROW+1) * ScGlobal::nStdRowHeight * HMM_PER_TWIPS );
+            sal_uLong const nx = sal_uLong(double(pDocument->MaxCol()+1) * STD_COL_WIDTH           * HMM_PER_TWIPS );
+            sal_uLong ny = static_cast<sal_uLong>(double(pDocument->MaxRow()+1) * ScGlobal::nStdRowHeight * HMM_PER_TWIPS );
             pDrawLayer->SetPageSize( static_cast<sal_uInt16>(nTab), Size( nx, ny ), false );
         }
     }
@@ -599,7 +599,7 @@ bool ScTable::GetPrintArea( SCCOL& rEndCol, SCROW& rEndRow, bool bNotes ) const
         }
     }
 
-    if (nMaxX == MAXCOL)                    // omit attribute at the right
+    if (nMaxX == pDocument->MaxCol())                    // omit attribute at the right
     {
         --nMaxX;
         while ( nMaxX>0 && aCol[nMaxX].IsVisibleAttrEqual(aCol[nMaxX+1]) )
@@ -654,7 +654,7 @@ bool ScTable::GetPrintAreaHor( SCROW nStartRow, SCROW nEndRow,
         }
     }
 
-    if (nMaxX == MAXCOL)                    // omit attribute at the right
+    if (nMaxX == pDocument->MaxCol())                    // omit attribute at the right
     {
         --nMaxX;
         while ( nMaxX>0 && aCol[nMaxX].IsVisibleAttrEqual(aCol[nMaxX+1], nStartRow, nEndRow) )
@@ -723,7 +723,7 @@ bool ScTable::GetDataStart( SCCOL& rStartCol, SCROW& rStartRow ) const
 {
     bool bFound = false;
     SCCOL nMinX = aCol.size()-1;
-    SCROW nMinY = MAXROW;
+    SCROW nMinY = pDocument->MaxRow();
     SCCOL i;
 
     for (i=0; i<aCol.size(); i++)                   // Test attribute
@@ -815,7 +815,7 @@ void ScTable::GetDataArea( SCCOL& rStartCol, SCROW& rStartRow, SCCOL& rEndCol, S
             SCROW nStart = rStartRow;
             SCROW nEnd = rEndRow;
             if (nStart>0) --nStart;
-            if (nEnd<MAXROW) ++nEnd;
+            if (nEnd<pDocument->MaxRow()) ++nEnd;
 
             if (rEndCol < (aCol.size()-1))
                 if (!aCol[rEndCol+1].IsEmptyBlock(nStart,nEnd))
@@ -852,7 +852,7 @@ void ScTable::GetDataArea( SCCOL& rStartCol, SCROW& rStartRow, SCCOL& rEndCol, S
             }
         }
 
-        if (rEndRow < MAXROW)
+        if (rEndRow < pDocument->MaxRow())
         {
             SCROW nTest = rEndRow+1;
             bool needExtend = false;
@@ -879,7 +879,7 @@ void ScTable::GetDataArea( SCCOL& rStartCol, SCROW& rStartRow, SCCOL& rEndCol, S
             while ( rEndCol > 0 && rStartCol < rEndCol && aCol[rEndCol].IsEmptyBlock(rStartRow,rEndRow) )
                 --rEndCol;
 
-        if ( !bTop && rStartRow < MAXROW && rStartRow < rEndRow )
+        if ( !bTop && rStartRow < pDocument->MaxRow() && rStartRow < rEndRow )
         {
             bool bShrink = true;
             do
@@ -889,7 +889,7 @@ void ScTable::GetDataArea( SCCOL& rStartCol, SCROW& rStartRow, SCCOL& rEndCol, S
                         bShrink = false;
                 if (bShrink)
                     ++rStartRow;
-            } while (bShrink && rStartRow < MAXROW && rStartRow < rEndRow);
+            } while (bShrink && rStartRow < pDocument->MaxRow() && rStartRow < rEndRow);
         }
     }
 
@@ -971,9 +971,9 @@ bool ScTable::ShrinkToUsedDataArea( bool& o_bShrunk, SCCOL& rStartCol, SCROW& rS
         rEndCol = aCol.size()-1;
         o_bShrunk = true;
     }
-    if (rEndRow > MAXROW)
+    if (rEndRow > pDocument->MaxRow())
     {
-        rEndRow = MAXROW;
+        rEndRow = pDocument->MaxRow();
         o_bShrunk = true;
     }
 
@@ -1173,12 +1173,12 @@ SCCOL ScTable::FindNextVisibleCol( SCCOL nCol, bool bRight ) const
         if(bHidden)
             nCol = nEnd +1;
 
-        return std::min<SCCOL>(MAXCOL, nCol);
+        return std::min<SCCOL>(pDocument->MaxCol(), nCol);
     }
     else
     {
         nCol--;
-        SCCOL nStart = MAXCOL;
+        SCCOL nStart = pDocument->MaxCol();
         bool bHidden = pDocument->ColHidden(nCol, nTab, &nStart);
         if(bHidden)
             nCol = nStart - 1;
@@ -1193,9 +1193,9 @@ SCCOL ScTable::FindNextVisibleColWithContent( SCCOL nCol, bool bRight, SCROW nRo
     if(bRight)
     {
         // If nCol is the last allocated column index, there won't be any content to its right.
-        // To maintain the original return behaviour, return MAXCOL.
+        // To maintain the original return behaviour, return pDocument->MaxCol().
         if(nCol >= nLastCol)
-            return MAXCOL;
+            return pDocument->MaxCol();
 
         do
         {
@@ -1206,9 +1206,9 @@ SCCOL ScTable::FindNextVisibleColWithContent( SCCOL nCol, bool bRight, SCROW nRo
             {
                 nCol = nEndCol +1;
                 // Can end search early as there is no data after nLastCol.
-                // For nCol == nLastCol, it may still have data so don't want to return MAXCOL.
+                // For nCol == nLastCol, it may still have data so don't want to return pDocument->MaxCol().
                 if(nCol > nLastCol)
-                    return MAXCOL;
+                    return pDocument->MaxCol();
             }
 
             if(aCol[nCol].HasVisibleDataAt(nRow))
@@ -1216,11 +1216,11 @@ SCCOL ScTable::FindNextVisibleColWithContent( SCCOL nCol, bool bRight, SCROW nRo
         }
         while(nCol < nLastCol); // Stop search as soon as the last allocated column is searched.
 
-        return MAXCOL;
+        return pDocument->MaxCol();
     }
     else
     {
-        // If nCol is in the unallocated range [nLastCol+1, MAXCOL], then move it directly to nLastCol
+        // If nCol is in the unallocated range [nLastCol+1, pDocument->MaxCol()], then move it directly to nLastCol
         // as there is no data in the unallocated range. This also makes the search faster and avoids
         // the need for more range checks in the loop below.
         if ( nCol > nLastCol )
@@ -1232,7 +1232,7 @@ SCCOL ScTable::FindNextVisibleColWithContent( SCCOL nCol, bool bRight, SCROW nRo
         do
         {
             nCol--;
-            SCCOL nStartCol = MAXCOL;
+            SCCOL nStartCol = pDocument->MaxCol();
             bool bHidden = pDocument->ColHidden( nCol, nTab, &nStartCol );
             if(bHidden)
             {
@@ -1261,7 +1261,7 @@ void ScTable::FindAreaPos( SCCOL& rCol, SCROW& rRow, ScMoveDirection eDirection
         bool bRight = (eDirection == SC_MOVE_RIGHT);
         if (bThere)
         {
-            if(nNewCol >= MAXCOL && eDirection == SC_MOVE_RIGHT)
+            if(nNewCol >= pDocument->MaxCol() && eDirection == SC_MOVE_RIGHT)
                 return;
             else if(nNewCol == 0 && eDirection == SC_MOVE_LEFT)
                 return;
@@ -1280,7 +1280,7 @@ void ScTable::FindAreaPos( SCCOL& rCol, SCROW& rRow, ScMoveDirection eDirection
                     else
                         bFound = true;
                 }
-                while(!bFound && nNextCol > 0 && nNextCol < MAXCOL);
+                while(!bFound && nNextCol > 0 && nNextCol < pDocument->MaxCol());
             }
             else
             {
@@ -1294,8 +1294,8 @@ void ScTable::FindAreaPos( SCCOL& rCol, SCROW& rRow, ScMoveDirection eDirection
 
         if (nNewCol<0)
             nNewCol=0;
-        if (nNewCol>MAXCOL)
-            nNewCol=MAXCOL;
+        if (nNewCol>pDocument->MaxCol())
+            nNewCol=pDocument->MaxCol();
         rCol = nNewCol;
     }
     else
@@ -1305,9 +1305,9 @@ void ScTable::FindAreaPos( SCCOL& rCol, SCROW& rRow, ScMoveDirection eDirection
         else
         {
             // The cell (rCol, rRow) is equivalent to an empty cell (although not allocated).
-            // Set rRow to 0 or MAXROW depending on eDirection to maintain the behaviour of
+            // Set rRow to 0 or pDocument->MaxRow() depending on eDirection to maintain the behaviour of
             // ScColumn::FindDataAreaPos() when the given column is empty.
-            rRow = ( eDirection == SC_MOVE_DOWN ) ? MAXROW : 0;
+            rRow = ( eDirection == SC_MOVE_DOWN ) ? pDocument->MaxRow() : 0;
         }
     }
 }
@@ -1358,7 +1358,7 @@ bool ScTable::SkipRow( const SCCOL nCol, SCROW& rRow, const SCROW nMovY,
     if (bSheetProtected && pDocument->HasAttrib( nCol, rRow, nTab, nCol, rRow, nTab, HasAttrFlags::Protected))
     {
         if ( rRow > nUsedY )
-            rRow = (bUp ? nUsedY : MAXROW + nMovY);
+            rRow = (bUp ? nUsedY : pDocument->MaxRow() + nMovY);
         else
             rRow += nMovY;
 
@@ -1434,8 +1434,8 @@ void ScTable::GetNextPos( SCCOL& rCol, SCROW& rRow, SCCOL nMovX, SCROW nMovY,
         // visually different from empty") to enable travelling through
         // protected forms with empty cells and no visual indicator.
         // 42 might be good enough and not too much...
-        nEndCol = std::min<SCCOL>( nEndCol+42, MAXCOL);
-        nEndRow = std::min<SCROW>( nEndRow+42, MAXROW);
+        nEndCol = std::min<SCCOL>( nEndCol+42, pDocument->MaxCol());
+        nEndRow = std::min<SCROW>( nEndRow+42, pDocument->MaxRow());
     }
     else
     {
@@ -1608,10 +1608,10 @@ bool ScTable::GetNextMarkedCell( SCCOL& rCol, SCROW& rRow, const ScMarkData& rMa
     while ( rCol < aCol.size() )
     {
         ScMarkArray aArray( rMark.GetMarkArray( rCol ) );
-        while ( rRow <= MAXROW )
+        while ( rRow <= pDocument->MaxRow() )
         {
             SCROW nStart = aArray.GetNextMarked( rRow, false );
-            if ( nStart <= MAXROW )
+            if ( nStart <= pDocument->MaxRow() )
             {
                 SCROW nEnd = aArray.GetMarkEnd( nStart, false );
 
@@ -1627,7 +1627,7 @@ bool ScTable::GetNextMarkedCell( SCCOL& rCol, SCROW& rRow, const ScMarkData& rMa
                     if (it == rCells.end())
                     {
                         // No more block.  Move on to the next column.
-                        rRow = MAXROW + 1;
+                        rRow = pDocument->MaxRow() + 1;
                         continue;
                     }
                 }
@@ -1642,14 +1642,14 @@ bool ScTable::GetNextMarkedCell( SCCOL& rCol, SCROW& rRow, const ScMarkData& rMa
                 rRow = nEnd + 1;                // Search for next selected range
             }
             else
-                rRow = MAXROW + 1;              // End of column
+                rRow = pDocument->MaxRow() + 1;              // End of column
         }
         rRow = 0;
         ++rCol;                                 // test next column
     }
 
-    // Though searched only the allocated columns, it is equivalent to a search till MAXCOL.
-    rCol = MAXCOL + 1;
+    // Though searched only the allocated columns, it is equivalent to a search till pDocument->MaxCol().
+    rCol = pDocument->MaxCol() + 1;
     return false;                               // Through all columns
 }
 
@@ -1689,7 +1689,7 @@ void ScTable::UpdateReference(
     else
     {
         i = 0;
-        iMax = MAXCOL;
+        iMax = pDocument->MaxCol();
     }
 
     UpdateRefMode eUpdateRefMode = rCxt.meMode;
@@ -1783,7 +1783,7 @@ void ScTable::UpdateReference(
         {
             UpdatePageBreaks(nullptr);
 
-            pDocument->RepaintRange( ScRange(0,0,nTab,MAXCOL,MAXROW,nTab) );
+            pDocument->RepaintRange( ScRange(0,0,nTab,pDocument->MaxCol(),pDocument->MaxRow(),nTab) );
         }
     }
 
@@ -1830,7 +1830,7 @@ void ScTable::UpdateInsertTab( sc::RefUpdateInsertTabContext& rCxt )
 
     if (pTabProtection)
         pTabProtection->updateReference( URM_INSDEL, pDocument,
-                ScRange( 0, 0, rCxt.mnInsertPos, MAXCOL, MAXROW, MAXTAB),
+                ScRange( 0, 0, rCxt.mnInsertPos, pDocument->MaxCol(), pDocument->MaxRow(), MAXTAB),
                 0, 0, rCxt.mnSheets);
 
     for (SCCOL i=0; i < aCol.size(); i++)
@@ -1859,7 +1859,7 @@ void ScTable::UpdateDeleteTab( sc::RefUpdateDeleteTabContext& rCxt )
 
     if (pTabProtection)
         pTabProtection->updateReference( URM_INSDEL, pDocument,
-                ScRange( 0, 0, rCxt.mnDeletePos, MAXCOL, MAXROW, MAXTAB),
+                ScRange( 0, 0, rCxt.mnDeletePos, pDocument->MaxCol(), pDocument->MaxRow(), MAXTAB),
                 0, 0, -rCxt.mnSheets);
 
     for (SCCOL i = 0; i < aCol.size(); ++i)
@@ -1883,7 +1883,7 @@ void ScTable::UpdateMoveTab(
 
     if (pTabProtection)
         pTabProtection->updateReference( URM_REORDER, pDocument,
-                ScRange( 0, 0, rCxt.mnOldPos, MAXCOL, MAXROW, MAXTAB),
+                ScRange( 0, 0, rCxt.mnOldPos, pDocument->MaxCol(), pDocument->MaxRow(), MAXTAB),
                 0, 0, rCxt.mnNewPos - rCxt.mnOldPos);
 
     for ( SCCOL i=0; i < aCol.size(); i++ )
@@ -1934,8 +1934,8 @@ void ScTable::ExtendPrintArea( OutputDevice* pDev,
     // First, mark those columns that we need to skip i.e. hidden and empty columns.
 
     ScFlatBoolColSegments aSkipCols;
-    aSkipCols.setFalse(0, MAXCOL);
-    for (SCCOL i = 0; i <= MAXCOL; ++i)
+    aSkipCols.setFalse(0, pDocument->MaxCol());
+    for (SCCOL i = 0; i <= pDocument->MaxCol(); ++i)
     {
         SCCOL nLastCol = i;
         if (ColHidden(i, nullptr, &nLastCol))
@@ -1950,7 +1950,7 @@ void ScTable::ExtendPrintArea( OutputDevice* pDev,
             {
                 if ( j >= aCol.size() )
                 {
-                    aSkipCols.setTrue( j, MAXCOL );
+                    aSkipCols.setTrue( j, pDocument->MaxCol() );
                     break;
                 }
                 if (aCol[j].GetCellCount() == 0)
@@ -1979,7 +1979,7 @@ void ScTable::ExtendPrintArea( OutputDevice* pDev,
         for (SCCOL nDataCol = nCol; 0 <= nDataCol && nDataCol >= aColData.mnCol1; --nDataCol)
         {
             SCCOL nPrintCol = nDataCol;
-            VisibleDataCellIterator aIter(*mpHiddenRows, aCol[nDataCol]);
+            VisibleDataCellIterator aIter(pDocument, *mpHiddenRows, aCol[nDataCol]);
             ScRefCellValue aCell = aIter.reset(nStartRow);
             if (aCell.isEmpty())
                 // No visible cells found in this column.  Skip it.
@@ -2057,7 +2057,7 @@ void ScTable::MaybeAddExtraColumn(SCCOL& rCol, SCROW nRow, OutputDevice* pDev, d
     }
 
     SCCOL nNewCol = rCol;
-    while (nMissing > 0 && nNewCol < MAXCOL)
+    while (nMissing > 0 && nNewCol < pDocument->MaxCol())
     {
         auto nNextCol = nNewCol + 1;
         bool bNextEmpty = true;
@@ -2193,7 +2193,8 @@ void ScTable::RestorePrintRanges( const ScPrintSaverTab& rSaveTab )
     UpdatePageBreaks(nullptr);
 }
 
-ScTable::VisibleDataCellIterator::VisibleDataCellIterator(ScFlatBoolRowSegments& rRowSegs, ScColumn& rColumn) :
+ScTable::VisibleDataCellIterator::VisibleDataCellIterator(const ScDocument* pDoc, ScFlatBoolRowSegments& rRowSegs, ScColumn& rColumn) :
+    mpDocument(pDoc),
     mrRowSegs(rRowSegs),
     mrColumn(rColumn),
     mnCurRow(ROW_NOT_FOUND),
@@ -2207,7 +2208,7 @@ ScTable::VisibleDataCellIterator::~VisibleDataCellIterator()
 
 ScRefCellValue ScTable::VisibleDataCellIterator::reset(SCROW nRow)
 {
-    if (nRow > MAXROW)
+    if (nRow > mpDocument->MaxRow())
     {
         mnCurRow = ROW_NOT_FOUND;
         return ScRefCellValue();
@@ -2232,7 +2233,7 @@ ScRefCellValue ScTable::VisibleDataCellIterator::reset(SCROW nRow)
         // the next segment.
         mnCurRow = aData.mnRow2 + 1;
         mnUBound = mnCurRow; // get range data on the next iteration.
-        if (mnCurRow > MAXROW)
+        if (mnCurRow > mpDocument->MaxRow())
         {
             // Make sure the row doesn't exceed our current limit.
             mnCurRow = ROW_NOT_FOUND;
diff --git a/sc/source/core/data/table2.cxx b/sc/source/core/data/table2.cxx
index 2b300d8e0448..4c36c7b63494 100644
--- a/sc/source/core/data/table2.cxx
+++ b/sc/source/core/data/table2.cxx
@@ -132,7 +132,7 @@ bool ScTable::TestInsertRow( SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SC
 {
     bool bTest = true;
 
-    if ( nStartCol==0 && nEndCol==MAXCOL && pOutlineTable )
+    if ( nStartCol==0 && nEndCol==pDocument->MaxCol() && pOutlineTable )
         bTest = pOutlineTable->TestInsertRow(nSize);
 
     for (SCCOL i=nStartCol; (i<=nEndCol) && bTest; i++)
@@ -143,7 +143,7 @@ bool ScTable::TestInsertRow( SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SC
 
 void ScTable::InsertRow( SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SCSIZE nSize )
 {
-    if (nStartCol==0 && nEndCol==MAXCOL)
+    if (nStartCol==0 && nEndCol==pDocument->MaxCol())
     {
         if (mpRowHeights && pRowFlags)
         {
@@ -193,7 +193,7 @@ void ScTable::DeleteRow(
     const sc::ColumnSet& rRegroupCols, SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SCSIZE nSize,
     bool* pUndoOutline, std::vector<ScAddress>* pGroupPos )
 {
-    if (nStartCol==0 && nEndCol==MAXCOL)
+    if (nStartCol==0 && nEndCol==pDocument->MaxCol())
     {
         if (pRowFlags)
             pRowFlags->Remove( nStartRow, nSize);
@@ -249,14 +249,14 @@ void ScTable::DeleteRow(
 
 bool ScTable::TestInsertCol( SCROW nStartRow, SCROW nEndRow, SCSIZE nSize ) const
 {
-    if ( nSize > static_cast<SCSIZE>(MAXCOL) )
+    if ( nSize > static_cast<SCSIZE>(pDocument->MaxCol()) )
         return false;
 
-    if ( nStartRow==0 && nEndRow==MAXROW && pOutlineTable
+    if ( nStartRow==0 && nEndRow==pDocument->MaxRow() && pOutlineTable
         && ! pOutlineTable->TestInsertCol(nSize) )
             return false;
 
-    auto range = GetColumnsRange( MAXCOL - static_cast<SCCOL>(nSize) + 1, MAXCOL );
+    auto range = GetColumnsRange( pDocument->MaxCol() - static_cast<SCCOL>(nSize) + 1, pDocument->MaxCol() );
     for (auto it = range.rbegin(); it != range.rend(); ++it )
         if (! aCol[*it].TestInsertCol(nStartRow, nEndRow))
             return false;
@@ -267,13 +267,13 @@ bool ScTable::TestInsertCol( SCROW nStartRow, SCROW nEndRow, SCSIZE nSize ) cons
 void ScTable::InsertCol(
     const sc::ColumnSet& rRegroupCols, SCCOL nStartCol, SCROW nStartRow, SCROW nEndRow, SCSIZE nSize )
 {
-    if (nStartRow==0 && nEndRow==MAXROW)
+    if (nStartRow==0 && nEndRow==pDocument->MaxRow())
     {
         if (mpColWidth && mpColFlags)
         {
             mpColWidth->InsertPreservingSize(nStartCol, nSize, STD_COL_WIDTH);
             // The inserted columns have the same widths as the columns, which were selected for insert.
-            for (SCSIZE i=0; i < std::min(MAXCOL-nSize-nStartCol, nSize); ++i)
+            for (SCSIZE i=0; i < std::min(pDocument->MaxCol()-nSize-nStartCol, nSize); ++i)
                 mpColWidth->SetValue(nStartCol + i, mpColWidth->GetValue(nStartCol+i+nSize));
             mpColFlags->InsertPreservingSize(nStartCol, nSize, CRFlags::NONE);
         }
@@ -299,7 +299,7 @@ void ScTable::InsertCol(
         }
     }
 
-    if ((nStartRow == 0) && (nEndRow == MAXROW))
+    if ((nStartRow == 0) && (nEndRow == pDocument->MaxRow()))
     {
         for (SCSIZE i=0; i < nSize; i++)
             for (SCCOL nCol = aCol.size() - 1; nCol > nStartCol; nCol--)
@@ -344,11 +344,11 @@ void ScTable::InsertCol(
 void ScTable::DeleteCol(
     const sc::ColumnSet& rRegroupCols, SCCOL nStartCol, SCROW nStartRow, SCROW nEndRow, SCSIZE nSize, bool* pUndoOutline )
 {
-    if (nStartRow==0 && nEndRow==MAXROW)
+    if (nStartRow==0 && nEndRow==pDocument->MaxRow())
     {
         if (mpColWidth && mpColFlags)
         {
-            assert( nStartCol + nSize <= MAXCOL+1 );    // moving 0 if ==MAXCOL+1 is correct
+            assert( nStartCol + nSize <= size_t(pDocument->MaxCol()+1) );    // moving 0 if ==pDocument->MaxCol()+1 is correct
             mpColWidth->RemovePreservingSize(nStartCol, nSize, STD_COL_WIDTH);
             mpColFlags->RemovePreservingSize(nStartCol, nSize, CRFlags::NONE);
         }
@@ -384,7 +384,7 @@ void ScTable::DeleteCol(
     for (SCSIZE i = 0; i < nSize; i++)
         aCol[nStartCol + i].DeleteArea(nStartRow, nEndRow, InsertDeleteFlags::ALL, false);
 
-    if ((nStartRow == 0) && (nEndRow == MAXROW))
+    if ((nStartRow == 0) && (nEndRow == pDocument->MaxRow()))
     {
         for (SCSIZE i=0; i < nSize; i++)
             for (SCCOL nCol = nStartCol; nCol < aCol.size() - 1; nCol++)
@@ -412,7 +412,7 @@ void ScTable::DeleteArea(
     bool bBroadcast, sc::ColumnSpanSet* pBroadcastSpans )
 {
     if ( nCol2 >= aCol.size() ) nCol2 = aCol.size() - 1;
-    if (nRow2 > MAXROW) nRow2 = MAXROW;
+    if (nRow2 > pDocument->MaxRow()) nRow2 = pDocument->MaxRow();
     if (ValidColRow(nCol1, nRow1) && ValidColRow(nCol2, nRow2))
     {
         {   // scope for bulk broadcast
@@ -713,10 +713,10 @@ void ScTable::CopyFromClip(
     sc::CopyFromClipContext& rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
     SCCOL nDx, SCROW nDy, ScTable* pTable )
 {
-    if (nCol2 > MAXCOL)
-        nCol2 = MAXCOL;
-    if (nRow2 > MAXROW)
-        nRow2 = MAXROW;
+    if (nCol2 > pDocument->MaxCol())
+        nCol2 = pDocument->MaxCol();
+    if (nRow2 > pDocument->MaxRow())
+        nRow2 = pDocument->MaxRow();
 
     if (ValidColRow(nCol1, nRow1) && ValidColRow(nCol2, nRow2))
     {
@@ -739,10 +739,10 @@ void ScTable::CopyFromClip(
 
         if ((rCxt.getInsertFlag() & InsertDeleteFlags::ATTRIB) != InsertDeleteFlags::NONE)
         {
-            if (nRow1==0 && nRow2==MAXROW && mpColWidth && pTable->mpColWidth)
+            if (nRow1==0 && nRow2==pDocument->MaxRow() && mpColWidth && pTable->mpColWidth)
                 mpColWidth->CopyFrom(*pTable->mpColWidth, nCol1, nCol2, nCol1 - nDx);
 
-            if (nCol1==0 && nCol2==MAXCOL && mpRowHeights && pTable->mpRowHeights &&
+            if (nCol1==0 && nCol2==pDocument->MaxCol() && mpRowHeights && pTable->mpRowHeights &&
                                              pRowFlags && pTable->pRowFlags)
             {
                 CopyRowHeight(*pTable, nRow1, nRow2, -nDy);
@@ -969,10 +969,10 @@ void ScTable::TransposeClip( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
                     if (rOldMerge.IsMerged())
                         rNewSet.Put( ScMergeAttr( std::min(
                                         static_cast<SCCOL>(rOldMerge.GetRowMerge()),
-                                        static_cast<SCCOL>(MAXCOL+1 - (nAttrRow2-nRow1))),
+                                        static_cast<SCCOL>(pDocument->MaxCol()+1 - (nAttrRow2-nRow1))),
                                     std::min(
                                         static_cast<SCROW>(rOldMerge.GetColMerge()),
-                                        static_cast<SCROW>(MAXROW+1 - (nCol-nCol1)))));
+                                        static_cast<SCROW>(pDocument->MaxRow()+1 - (nCol-nCol1)))));
                     const ScMergeFlagAttr& rOldFlag = rSet.Get(ATTR_MERGE_FLAG);
                     if (rOldFlag.IsOverlapped())
                     {
@@ -1138,8 +1138,8 @@ void ScTable::SetDirtyFromClip(
     SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, sc::ColumnSpanSet& rBroadcastSpans )
 {
     if ( nCol2 >= aCol.size() ) nCol2 = aCol.size() - 1;
-    if (nCol2 > MAXCOL) nCol2 = MAXCOL;
-    if (nRow2 > MAXROW) nRow2 = MAXROW;
+    if (nCol2 > pDocument->MaxCol()) nCol2 = pDocument->MaxCol();
+    if (nRow2 > pDocument->MaxRow()) nRow2 = pDocument->MaxRow();
     if (ValidColRow(nCol1, nRow1) && ValidColRow(nCol2, nRow2))
         for (SCCOL i = nCol1; i <= nCol2; i++)
             aCol[i].SetDirtyFromClip(nRow1, nRow2, rBroadcastSpans);
@@ -1150,8 +1150,8 @@ void ScTable::StartListeningFormulaCells(
     SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 )
 {
     if ( nCol2 >= aCol.size() ) nCol2 = aCol.size() - 1;
-    if (nCol2 > MAXCOL) nCol2 = MAXCOL;
-    if (nRow2 > MAXROW) nRow2 = MAXROW;
+    if (nCol2 > pDocument->MaxCol()) nCol2 = pDocument->MaxCol();
+    if (nRow2 > pDocument->MaxRow()) nRow2 = pDocument->MaxRow();
     if (ValidColRow(nCol1, nRow1) && ValidColRow(nCol2, nRow2))
         for (SCCOL i = nCol1; i <= nCol2; i++)
             aCol[i].StartListeningFormulaCells(rStartCxt, rEndCxt, nRow1, nRow2);
@@ -1202,8 +1202,8 @@ void ScTable::CopyToTable(
 
     bool bFlagChange = false;
 
-    bool bWidth  = (nRow1==0 && nRow2==MAXROW && mpColWidth && pDestTab->mpColWidth);
-    bool bHeight = (nCol1==0 && nCol2==MAXCOL && mpRowHeights && pDestTab->mpRowHeights);
+    bool bWidth  = (nRow1==0 && nRow2==pDocument->MaxRow() && mpColWidth && pDestTab->mpColWidth);
+    bool bHeight = (nCol1==0 && nCol2==pDocument->MaxCol() && mpRowHeights && pDestTab->mpRowHeights);
 
     if (bWidth || bHeight)
     {
@@ -1221,7 +1221,7 @@ void ScTable::CopyToTable(
                 pDestTab->SetColHidden(i, i, bThisHidden);
                 //TODO: collect changes?
                 if (bHiddenChange && pCharts)
-                    pCharts->SetRangeDirty(ScRange( i, 0, nTab, i, MAXROW, nTab ));
+                    pCharts->SetRangeDirty(ScRange( i, 0, nTab, i, pDocument->MaxRow(), nTab ));
 
                 if (bChange)
                     bFlagChange = true;
@@ -1254,7 +1254,7 @@ void ScTable::CopyToTable(
                 bool bHiddenChanged = pDestTab->SetRowHidden(i, nLastRow, bHidden);
                 if (bHiddenChanged && pCharts)
                     // Hidden flags differ.
-                    pCharts->SetRangeDirty(ScRange(0, i, nTab, MAXCOL, nLastRow, nTab));
+                    pCharts->SetRangeDirty(ScRange(0, i, nTab, pDocument->MaxCol(), nLastRow, nTab));
 
                 if (bHiddenChanged)
                     bFlagChange = true;
@@ -1317,15 +1317,15 @@ void ScTable::UndoToTable(
 {
     if (ValidColRow(nCol1, nRow1) && ValidColRow(nCol2, nRow2))
     {
-        bool bWidth  = (nRow1==0 && nRow2==MAXROW && mpColWidth && pDestTab->mpColWidth);
-        bool bHeight = (nCol1==0 && nCol2==MAXCOL && mpRowHeights && pDestTab->mpRowHeights);
+        bool bWidth  = (nRow1==0 && nRow2==pDocument->MaxRow() && mpColWidth && pDestTab->mpColWidth);
+        bool bHeight = (nCol1==0 && nCol2==pDocument->MaxCol() && mpRowHeights && pDestTab->mpRowHeights);
 
         for ( SCCOL i = 0; i < aCol.size(); i++)
         {
             if ( i >= nCol1 && i <= nCol2 )
                 aCol[i].UndoToColumn(rCxt, nRow1, nRow2, nFlags, bMarked, pDestTab->aCol[i]);
             else
-                aCol[i].CopyToColumn(rCxt, 0, MAXROW, InsertDeleteFlags::FORMULA, false, pDestTab->aCol[i]);
+                aCol[i].CopyToColumn(rCxt, 0, pDocument->MaxRow(), InsertDeleteFlags::FORMULA, false, pDestTab->aCol[i]);
         }
 
         if (nFlags & InsertDeleteFlags::ATTRIB)
@@ -1489,7 +1489,7 @@ SCROW ScTable::GetFirstEditTextRow( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW
         return -1;
 
     nCol2 = ClampToAllocatedColumns(nCol2);
-    SCROW nFirst = MAXROW+1;
+    SCROW nFirst = pDocument->MaxRow()+1;
     for (SCCOL i = nCol1; i <= nCol2; ++i)
     {
         const ScColumn& rCol = aCol[i];
@@ -1504,7 +1504,7 @@ SCROW ScTable::GetFirstEditTextRow( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW
         }
     }
 
-    return nFirst == (MAXROW+1) ? -1 : nFirst;
+    return nFirst == (pDocument->MaxRow()+1) ? -1 : nFirst;
 }
 
 void ScTable::SetEmptyCell( SCCOL nCol, SCROW nRow )
@@ -1734,7 +1734,7 @@ CommentCaptionState ScTable::GetAllNoteCaptionsState(const ScRange& rRange, std:
 void ScTable::GetUnprotectedCells( ScRangeList& rRangeList ) const
 {
     for (auto const & pCol : aCol)
-        pCol->GetUnprotectedCells(0, MAXROW, rRangeList);
+        pCol->GetUnprotectedCells(0, pDocument->MaxRow(), rRangeList);
 }
 
 bool ScTable::ContainsNotesInRange( const ScRange& rRange ) const
@@ -1770,7 +1770,7 @@ ScRefCellValue ScTable::GetCellValue( SCCOL nCol, SCROW nRow ) const
 void ScTable::GetFirstDataPos(SCCOL& rCol, SCROW& rRow) const
 {
     rCol = 0;
-    rRow = MAXROW+1;
+    rRow = pDocument->MaxRow()+1;
     while (rCol < (aCol.size() - 1) && aCol[rCol].IsEmptyData() )
         ++rCol;
     SCCOL nCol = rCol;
@@ -1789,7 +1789,7 @@ void ScTable::GetLastDataPos(SCCOL& rCol, SCROW& rRow) const
     while (aCol[rCol].IsEmptyData() && (rCol > 0))
         rCol--;
     SCCOL nCol = rCol;
-    while (nCol >= 0 && rRow < MAXROW)
+    while (nCol >= 0 && rRow < pDocument->MaxRow())
         rRow = ::std::max( rRow, aCol[nCol--].GetLastDataPos());
 }
 
@@ -2208,7 +2208,7 @@ void ScTable::FindMaxRotCol( RowInfo* pRowInfo, SCSIZE nArrCount, SCCOL nX1, SCC
     SCROW nY1 = pRowInfo[0].nRowNo;
     SCROW nY2 = pRowInfo[nArrCount-1].nRowNo;
 
-    for (SCCOL nCol : GetColumnsRange(0, MAXCOL))
+    for (SCCOL nCol : GetColumnsRange(0, pDocument->MaxCol()))
     {
         if (!ColHidden(nCol))
         {
@@ -2697,7 +2697,7 @@ void ScTable::ApplyStyleArea( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, S
     {
         PutInOrder(nStartCol, nEndCol);
         PutInOrder(nStartRow, nEndRow);
-        if ( nEndCol == MAXCOL )
+        if ( nEndCol == pDocument->MaxCol() )
         {
             if ( nStartCol < aCol.size() )
             {
@@ -2826,7 +2826,7 @@ void ScTable::StyleSheetChanged( const SfxStyleSheetBase* pStyleSheet, bool bRem
 
     sc::RowHeightContext aCxt(nPPTX, nPPTY, rZoomX, rZoomY, pDev);
     SCROW nRow = 0;
-    while (nRow <= MAXROW)
+    while (nRow <= pDocument->MaxRow())
     {
         ScFlatBoolRowSegments::RangeData aData;
         if (!aUsedRows.getRangeData(nRow, aData))
@@ -3132,7 +3132,7 @@ sal_uInt16 ScTable::GetCommonWidth( SCCOL nEndCol ) const
     if ( !ValidCol(nEndCol) )
     {
         OSL_FAIL("wrong column");
-        nEndCol = MAXCOL;
+        nEndCol = pDocument->MaxCol();
     }
 
     sal_uInt16 nMaxWidth = 0;
@@ -3320,7 +3320,7 @@ void ScTable::ShowCol(SCCOL nCol, bool bShow)
 
             ScChartListenerCollection* pCharts = pDocument->GetChartListenerCollection();
             if ( pCharts )
-                pCharts->SetRangeDirty(ScRange( nCol, 0, nTab, nCol, MAXROW, nTab ));
+                pCharts->SetRangeDirty(ScRange( nCol, 0, nTab, nCol, pDocument->MaxRow(), nTab ));
         }
     }
     else
@@ -3341,7 +3341,7 @@ void ScTable::ShowRow(SCROW nRow, bool bShow)
                 SetRowFiltered(nRow, nRow, false);
             ScChartListenerCollection* pCharts = pDocument->GetChartListenerCollection();
             if ( pCharts )
-                pCharts->SetRangeDirty(ScRange( 0, nRow, nTab, MAXCOL, nRow, nTab ));
+                pCharts->SetRangeDirty(ScRange( 0, nRow, nTab, pDocument->MaxCol(), nRow, nTab ));
 
             InvalidatePageBreaks();
         }
@@ -3364,7 +3364,7 @@ void ScTable::DBShowRow(SCROW nRow, bool bShow)
         {
             ScChartListenerCollection* pCharts = pDocument->GetChartListenerCollection();
             if ( pCharts )
-                pCharts->SetRangeDirty(ScRange( 0, nRow, nTab, MAXCOL, nRow, nTab ));
+                pCharts->SetRangeDirty(ScRange( 0, nRow, nTab, pDocument->MaxCol(), nRow, nTab ));
 
             if (pOutlineTable)
                 UpdateOutlineRow( nRow, nRow, bShow );
@@ -3397,7 +3397,7 @@ void ScTable::DBShowRows(SCROW nRow1, SCROW nRow2, bool bShow)
         {
             ScChartListenerCollection* pCharts = pDocument->GetChartListenerCollection();
             if ( pCharts )
-                pCharts->SetRangeDirty(ScRange( 0, nStartRow, nTab, MAXCOL, nEndRow, nTab ));
+                pCharts->SetRangeDirty(ScRange( 0, nStartRow, nTab, pDocument->MaxCol(), nEndRow, nTab ));
         }
 
         nStartRow = nEndRow + 1;
@@ -3435,7 +3435,7 @@ void ScTable::ShowRows(SCROW nRow1, SCROW nRow2, bool bShow)
         {
             ScChartListenerCollection* pCharts = pDocument->GetChartListenerCollection();
             if ( pCharts )
-                pCharts->SetRangeDirty(ScRange( 0, nStartRow, nTab, MAXCOL, nEndRow, nTab ));
+                pCharts->SetRangeDirty(ScRange( 0, nStartRow, nTab, pDocument->MaxCol(), nEndRow, nTab ));
 
             InvalidatePageBreaks();
         }
@@ -3596,7 +3596,7 @@ void ScTable::ExtendHidden( SCCOL& rX1, SCROW& rY1, SCCOL& rX2, SCROW& rY2 )
     while (rX1 > 0 && ColHidden(rX1-1))
         --rX1;
 
-    while (rX2 < MAXCOL && ColHidden(rX2+1))
+    while (rX2 < pDocument->MaxCol() && ColHidden(rX2+1))
         ++rX2;
 
     // Row-wise expansion
@@ -3611,7 +3611,7 @@ void ScTable::ExtendHidden( SCCOL& rX1, SCROW& rY1, SCCOL& rX2, SCROW& rY2 )
                 rY1 = nStartRow;
         }
     }
-    if (rY2 < MAXROW)
+    if (rY2 < pDocument->MaxRow())
     {
         SCROW nEndRow = -1;
         if (RowHidden(rY2+1, nullptr, &nEndRow) && ValidRow(nEndRow))
@@ -3704,7 +3704,7 @@ void ScTable::DoAutoOutline( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SC
 
                             // Rows
 
-    UsedRowsType aUsed(0, MAXROW+1, false);
+    UsedRowsType aUsed(0, pDocument->MaxRow()+1, false);
     for (nCol=nStartCol; nCol<=nEndCol; nCol++)
         aCol[nCol].FindUsed(nStartRow, nEndRow, aUsed);
     aUsed.build_tree();
@@ -3845,8 +3845,8 @@ void ScTable::SetDrawPageSize(bool bResetStreamValid, bool bUpdateNoteCaptionPos
     ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer();
     if( pDrawLayer )
     {
-        double fValX = GetColOffset( MAXCOL + 1 ) * HMM_PER_TWIPS;
-        double fValY = GetRowOffset( MAXROW + 1 ) * HMM_PER_TWIPS;
+        double fValX = GetColOffset( pDocument->MaxCol() + 1 ) * HMM_PER_TWIPS;
+        double fValY = GetRowOffset( pDocument->MaxRow() + 1 ) * HMM_PER_TWIPS;
         const long nMax = ::std::numeric_limits<long>::max();
         // #i113884# Avoid int32 overflow with possible negative results than can cause bad effects.
         // If the draw page size is smaller than all rows, only the bottom of the sheet is affected.
@@ -3913,7 +3913,7 @@ SCROW ScTable::GetRowForHeight(sal_uLong nHeight) const
     aRowHeightRange.mnRow2 = -1;
     aRowHeightRange.mnValue = 0; // silence MSVC C4701
 
-    for (SCROW nRow = 0; nRow <= MAXROW; ++nRow)
+    for (SCROW nRow = 0; nRow <= pDocument->MaxRow(); ++nRow)
     {
         if (!mpHiddenRows->getRangeData(nRow, aData))
             // Failed to fetch the range data for whatever reason.
@@ -3937,8 +3937,8 @@ SCROW ScTable::GetRowForHeight(sal_uLong nHeight) const
 
         if (nSum > nHeight)
         {
-            if (nRow >= MAXROW)
-                return MAXROW;
+            if (nRow >= pDocument->MaxRow())
+                return pDocument->MaxRow();
 
             // Find the next visible row.
             ++nRow;
@@ -3951,7 +3951,7 @@ SCROW ScTable::GetRowForHeight(sal_uLong nHeight) const
                 // These rows are hidden.
                 nRow = aData.mnRow2 + 1;
 
-            return nRow <= MAXROW ? nRow : MAXROW;
+            return nRow <= pDocument->MaxRow() ? nRow : pDocument->MaxRow();
         }
     }
     return -1;
diff --git a/sc/source/core/data/table3.cxx b/sc/source/core/data/table3.cxx
index ed0bd17537a5..41a130d65f6c 100644
--- a/sc/source/core/data/table3.cxx
+++ b/sc/source/core/data/table3.cxx
@@ -1001,7 +1001,7 @@ void ScTable::SortReorderByColumn(
         sc::CellStoreType& rCells = aCol[nCol].maCells;
         sc::CellStoreType::position_type aPos = rCells.position(nRow1);
         sc::SharedFormulaUtil::joinFormulaCellAbove(aPos);
-        if (nRow2 < MAXROW)
+        if (nRow2 < pDocument->MaxRow())
         {
             aPos = rCells.position(aPos.first, nRow2+1);
             sc::SharedFormulaUtil::joinFormulaCellAbove(aPos);
@@ -1809,7 +1809,7 @@ public:
             if (mrTab.HasData(nCol, nRow))
                 return true;
         }
-        for (SCCOL nCol : mrTab.GetColumnsRange(nEndCol + 1, MAXCOL))
+        for (SCCOL nCol : mrTab.GetColumnsRange(nEndCol + 1, mrTab.GetDoc().MaxCol()))
         {
             if (mrTab.HasData(nCol, nRow))
                 return true;
@@ -1872,7 +1872,7 @@ void ScTable::RemoveSubTotals( ScSubTotalParam& rParam )
 
     std::for_each(aRows.rbegin(), aRows.rend(), [this](const SCROW nRow) {
             RemoveRowBreak(nRow+1, false, true);
-            pDocument->DeleteRow(0, nTab, MAXCOL, nTab, nRow, 1);
+            pDocument->DeleteRow(0, nTab, pDocument->MaxCol(), nTab, nRow, 1);
         });
 
     rParam.nRow2 -= aRows.size();
@@ -1939,7 +1939,7 @@ bool ScTable::DoSubTotals( ScSubTotalParam& rParam )
     sal_uInt16 i;
 
     //  Remove empty rows at the end
-    //  so that all exceeding (MAXROW) can be found by InsertRow (#35180#)
+    //  so that all exceeding (pDocument->MaxRow()) can be found by InsertRow (#35180#)
     //  If sorted, all empty rows are at the end.
     SCSIZE nEmpty = GetEmptyLinesInBlock( nStartCol, nStartRow, nEndCol, nEndRow, DIR_BOTTOM );
     nEndRow -= nEmpty;
@@ -2035,10 +2035,10 @@ bool ScTable::DoSubTotals( ScSubTotalParam& rParam )
                     aRowEntry.nFuncStart = aRowEntry.nSubStartRow;
                     aRowEntry.nFuncEnd   = nRow-1;
 
-                    bSpaceLeft = pDocument->InsertRow( 0, nTab, MAXCOL, nTab,
+                    bSpaceLeft = pDocument->InsertRow( 0, nTab, pDocument->MaxCol(), nTab,
                             aRowEntry.nDestRow, 1 );
                     DBShowRow( aRowEntry.nDestRow, bBlockVis );
-                    if ( rParam.bPagebreak && nRow < MAXROW &&
+                    if ( rParam.bPagebreak && nRow < pDocument->MaxRow() &&
                             aRowEntry.nSubStartRow != nStartRow && nLevel == 0)
                         SetRowBreak(aRowEntry.nSubStartRow, false, true);
 
@@ -2124,7 +2124,7 @@ bool ScTable::DoSubTotals( ScSubTotalParam& rParam )
             // increment row
             nGlobalEndFunc++;
 
-            bSpaceLeft = pDocument->InsertRow(0, nTab, MAXCOL, nTab, aRowEntry.nDestRow, 1);
+            bSpaceLeft = pDocument->InsertRow(0, nTab, pDocument->MaxCol(), nTab, aRowEntry.nDestRow, 1);
 
             if (bSpaceLeft)
             {
@@ -3551,7 +3551,7 @@ void ScTable::UpdateSelectionFunction( ScFunctionData& rData, const ScMarkData&
     {
         assert(!"ScTable::UpdateSelectionFunction - called without anything marked");
         aMarkArea.aStart.SetCol(0);
-        aMarkArea.aEnd.SetCol(MAXCOL);
+        aMarkArea.aEnd.SetCol(pDocument->MaxCol());
     }
     const SCCOL nStartCol = aMarkArea.aStart.Col();
     const SCCOL nEndCol = ClampToAllocatedColumns(aMarkArea.aEnd.Col());
diff --git a/sc/source/core/data/table4.cxx b/sc/source/core/data/table4.cxx
index 15e6cc719c9f..28b085fff466 100644
--- a/sc/source/core/data/table4.cxx
+++ b/sc/source/core/data/table4.cxx
@@ -2330,7 +2330,7 @@ void ScTable::UpdateInsertTabAbs(SCTAB nTable)
 bool ScTable::GetNextSpellingCell(SCCOL& rCol, SCROW& rRow, bool bInSel,
                                     const ScMarkData& rMark) const
 {
-    if (rRow == MAXROW+2)                       // end of table
+    if (rRow == pDocument->MaxRow()+2)                       // end of table
     {
         rRow = 0;
         rCol = 0;
@@ -2338,13 +2338,13 @@ bool ScTable::GetNextSpellingCell(SCCOL& rCol, SCROW& rRow, bool bInSel,
     else
     {
         rRow++;
-        if (rRow == MAXROW+1)
+        if (rRow == pDocument->MaxRow()+1)
         {
             rCol++;
             rRow = 0;
         }
     }
-    if (rCol == MAXCOL+1)
+    if (rCol == pDocument->MaxCol()+1)
         return true;
     for (;;)
     {
@@ -2354,7 +2354,7 @@ bool ScTable::GetNextSpellingCell(SCCOL& rCol, SCROW& rRow, bool bInSel,
             return true;
         if (aCol[rCol].GetNextSpellingCell(rRow, bInSel, rMark))
             return true;
-         /*else (rRow == MAXROW+1) */
+         /*else (rRow == pDocument->MaxRow()+1) */
         rCol++;
         rRow = 0;
     }
diff --git a/sc/source/core/data/table5.cxx b/sc/source/core/data/table5.cxx
index f4ecec8880a4..9975d96212c5 100644
--- a/sc/source/core/data/table5.cxx
+++ b/sc/source/core/data/table5.cxx
@@ -76,8 +76,8 @@ void ScTable::UpdatePageBreaks( const ScRange* pUserArea )
 
     SCCOL nStartCol = 0;
     SCROW nStartRow = 0;
-    SCCOL nEndCol = MAXCOL;
-    SCROW nEndRow = MAXROW;
+    SCCOL nEndCol = pDocument->MaxCol();
+    SCROW nEndRow = pDocument->MaxRow();
     if (pUserArea)
     {
         nStartCol = pUserArea->aStart.Col();
@@ -92,10 +92,10 @@ void ScTable::UpdatePageBreaks( const ScRange* pUserArea )
         {
             // Show nothing, when multiple ranges
 
-            for (SCCOL nX : GetColumnsRange(0, MAXCOL))
+            for (SCCOL nX : GetColumnsRange(0, pDocument->MaxCol()))
                 RemoveColBreak(nX, true, false);
 
-            RemoveRowPageBreaks(0, MAXROW-1);
+            RemoveRowPageBreaks(0, pDocument->MaxRow()-1);
 
             return;
         }
@@ -283,17 +283,17 @@ void ScTable::UpdatePageBreaks( const ScRange* pUserArea )
 
         //  End: Remove Break
 
-    if (nEndCol < MAXCOL)
+    if (nEndCol < pDocument->MaxCol())
     {
         SetColBreak(nEndCol+1, true, false);  // AREABREAK
-        for (SCCOL nCol : GetColumnsRange(nEndCol + 2, MAXCOL))
+        for (SCCOL nCol : GetColumnsRange(nEndCol + 2, pDocument->MaxCol()))
             RemoveColBreak(nCol, true, false);
     }
-    if (nEndRow < MAXROW)
+    if (nEndRow < pDocument->MaxRow())
     {
         SetRowBreak(nEndRow+1, true, false);  // AREABREAK
-        if (nEndRow+2 <= MAXROW)
-            RemoveRowPageBreaks(nEndRow+2, MAXROW);
+        if (nEndRow+2 <= pDocument->MaxRow())
+            RemoveRowPageBreaks(nEndRow+2, pDocument->MaxRow());
     }
     mbPageBreaksValid = !pUserArea;     // #i116881# the valid flag can only apply to the "no user area" case
 }
@@ -770,7 +770,7 @@ SCCOLROW ScTable::LastHiddenColRow(SCCOLROW nPos, bool bCol) const
         SCCOL nCol = static_cast<SCCOL>(nPos);
         if (ColHidden(nCol))
         {
-            for (SCCOL i = nCol+1; i <= MAXCOL; ++i)
+            for (SCCOL i = nCol+1; i <= pDocument->MaxCol(); ++i)
             {
                 if (!ColHidden(i))
                     return i - 1;
@@ -957,22 +957,22 @@ bool ScTable::IsManualRowHeight(SCROW nRow) const
 
 namespace {
 
-void lcl_syncFlags(ScFlatBoolColSegments& rColSegments, const ScFlatBoolRowSegments& rRowSegments,
+void lcl_syncFlags(const ScDocument* pDocument, ScFlatBoolColSegments& rColSegments, const ScFlatBoolRowSegments& rRowSegments,
     ScBitMaskCompressedArray<SCCOL, CRFlags>* pColFlags, ScBitMaskCompressedArray< SCROW, CRFlags>* pRowFlags, const CRFlags nFlagMask)
 {
     using ::sal::static_int_cast;
 
     CRFlags nFlagMaskComplement = ~nFlagMask;
 
-    pRowFlags->AndValue(0, MAXROW, nFlagMaskComplement);
-    pColFlags->AndValue(0, MAXCOL+1, nFlagMaskComplement);
+    pRowFlags->AndValue(0, pDocument->MaxRow(), nFlagMaskComplement);
+    pColFlags->AndValue(0, pDocument->MaxCol()+1, nFlagMaskComplement);
 
     {
         // row hidden flags.
 
         SCROW nRow = 0;
         ScFlatBoolRowSegments::RangeData aData;
-        while (nRow <= MAXROW)
+        while (nRow <= pDocument->MaxRow())
         {
             if (!rRowSegments.getRangeData(nRow, aData))
                 break;
@@ -989,7 +989,7 @@ void lcl_syncFlags(ScFlatBoolColSegments& rColSegments, const ScFlatBoolRowSegme
 
         SCCOL nCol = 0;
         ScFlatBoolColSegments::RangeData aData;
-        while (nCol <= MAXCOL)
+        while (nCol <= pDocument->MaxCol())
         {
             if (!rColSegments.getRangeData(nCol, aData))
                 break;
@@ -1009,8 +1009,8 @@ void ScTable::SyncColRowFlags()
     CRFlags nManualBreakComplement = ~CRFlags::ManualBreak;
 
     // Manual breaks.
-    pRowFlags->AndValue(0, MAXROW, nManualBreakComplement);
-    mpColFlags->AndValue(0, MAXCOL+1, nManualBreakComplement);
+    pRowFlags->AndValue(0, pDocument->MaxRow(), nManualBreakComplement);
+    mpColFlags->AndValue(0, pDocument->MaxCol()+1, nManualBreakComplement);
 
     for (const auto& rBreakPos : maRowManualBreaks)
         pRowFlags->OrValue(rBreakPos, CRFlags::ManualBreak);
@@ -1019,8 +1019,8 @@ void ScTable::SyncColRowFlags()
         mpColFlags->OrValue(rBreakPos, CRFlags::ManualBreak);
 
     // Hidden flags.
-    lcl_syncFlags(*mpHiddenCols, *mpHiddenRows, mpColFlags.get(), pRowFlags.get(), CRFlags::Hidden);
-    lcl_syncFlags(*mpFilteredCols, *mpFilteredRows, mpColFlags.get(), pRowFlags.get(), CRFlags::Filtered);
+    lcl_syncFlags(pDocument, *mpHiddenCols, *mpHiddenRows, mpColFlags.get(), pRowFlags.get(), CRFlags::Hidden);
+    lcl_syncFlags(pDocument, *mpFilteredCols, *mpFilteredRows, mpColFlags.get(), pRowFlags.get(), CRFlags::Filtered);
 }
 
 void ScTable::SetPageSize( const Size& rSize )
@@ -1200,7 +1200,7 @@ void ScTable::InvalidateTextWidth( const ScAddress* pAdrFrom, const ScAddress* p
     const SCCOL nCol1 = pAdrFrom ? pAdrFrom->Col() : 0;
     const SCROW nRow1 = pAdrFrom ? pAdrFrom->Row() : 0;
     const SCCOL nCol2 = pAdrTo   ? pAdrTo->Col()   : aCol.size() - 1;
-    const SCROW nRow2 = pAdrTo   ? pAdrTo->Row()   : MAXROW;
+    const SCROW nRow2 = pAdrTo   ? pAdrTo->Row()   : pDocument->MaxRow();
 
     for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
     {
diff --git a/sc/source/core/data/table6.cxx b/sc/source/core/data/table6.cxx
index 4daeb308bfd7..4d099866bf77 100644
--- a/sc/source/core/data/table6.cxx
+++ b/sc/source/core/data/table6.cxx
@@ -333,7 +333,7 @@ bool ScTable::Search(const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow,
         aCol[ i ].InitBlockPosition( blockPos[ i ] );
     if (!bAll && rSearchItem.GetBackward())
     {
-        SCROW nLastNonFilteredRow = MAXROW + 1;
+        SCROW nLastNonFilteredRow = pDocument->MaxRow() + 1;
         nCol = std::min(nCol, static_cast<SCCOL>(nLastCol + 1));
         nRow = std::min(nRow, static_cast<SCROW>(nLastRow + 1));
         if (rSearchItem.GetRowDirection())
@@ -405,7 +405,7 @@ bool ScTable::Search(const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow,
                     // Not found in this column.  Move to the next column.
                     bool bIsEmpty;
                     nRow = nLastRow;
-                    nLastNonFilteredRow = MAXROW + 1;
+                    nLastNonFilteredRow = pDocument->MaxRow() + 1;
                     do
                     {
                         nCol--;
@@ -476,7 +476,7 @@ bool ScTable::Search(const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW& rRow,
                         else
                         {
                             if (!aCol[nCol].GetNextDataPos(nRow))
-                                nRow = MAXROW + 1;
+                                nRow = pDocument->MaxRow() + 1;
                         }
                     }
                 }
@@ -627,7 +627,7 @@ bool ScTable::SearchStyle(const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW&
             SCROW nNextRow = aCol[nCol].SearchStyle( nRow, pSearchStyle, bBack, bSelect, rMark );
             if (!ValidRow(nNextRow))
             {
-                nRow = bBack ? MAXROW : 0;
+                nRow = bBack ? pDocument->MaxRow() : 0;
                 nCol = sal::static_int_cast<SCCOL>( nCol + nAdd );
             }
             else
@@ -669,7 +669,7 @@ bool ScTable::SearchStyle(const SvxSearchItem& rSearchItem, SCCOL& rCol, SCROW&
         }
         else                                // forwards
         {
-            nRow = MAXROW+1;
+            nRow = pDocument->MaxRow()+1;
             for (i=0; i < aColSize; ++i)
                 if (nNextRows[i]<nRow)
                 {
@@ -730,7 +730,7 @@ bool ScTable::SearchAllStyle(
         bool bFound = true;
         SCROW nRow = 0;
         SCROW nEndRow;
-        while (bFound && nRow <= MAXROW)
+        while (bFound && nRow <= pDocument->MaxRow())
         {
             bFound = aCol[i].SearchStyleRange( nRow, nEndRow, pSearchStyle, bBack, bSelect, rMark );
             if (bFound)
@@ -765,7 +765,7 @@ bool ScTable::ReplaceAllStyle(
         if (pReplaceStyle)
         {
             if (pUndoDoc)
-                pDocument->CopyToDocument(0, 0 ,nTab, MAXCOL,MAXROW,nTab,
+                pDocument->CopyToDocument(0, 0 ,nTab, pDocument->MaxCol(),pDocument->MaxRow(),nTab,
                                           InsertDeleteFlags::ATTRIB, true, *pUndoDoc, &rMark);
             ApplySelectionStyle( *pReplaceStyle, rMark );
         }
@@ -955,7 +955,7 @@ bool ScTable::SearchRangeForEmptyCell(
         if (rSearchItem.GetRowDirection())
         {
             // row direction.
-            SCROW nLastNonFilteredRow = MAXROW + 1;
+            SCROW nLastNonFilteredRow = pDocument->MaxRow() + 1;
             SCROW nBeginRow = std::min(rRange.aEnd.Row(), rRow);
             for (SCROW nRow = nBeginRow; nRow >= rRange.aStart.Row(); --nRow)
             {
@@ -982,7 +982,7 @@ bool ScTable::SearchRangeForEmptyCell(
             SCCOL nBeginCol = std::min(rRange.aEnd.Col(), rCol);
             for (SCCOL nCol = nBeginCol; nCol >= rRange.aStart.Col(); --nCol)
             {
-                SCROW nLastNonFilteredRow = MAXROW + 1;
+                SCROW nLastNonFilteredRow = pDocument->MaxRow() + 1;
                 SCROW nBeginRow = rRange.aEnd.Row();
                 if (nCol == rCol && nBeginRow >= rRow)
                     // always start from one cell before the cursor.
diff --git a/sc/source/core/data/table7.cxx b/sc/source/core/data/table7.cxx
index 76404c83afa9..29dd2ddc9041 100644
--- a/sc/source/core/data/table7.cxx
+++ b/sc/source/core/data/table7.cxx
@@ -141,7 +141,7 @@ void ScTable::CopyOneCellFromClip(
         }
     }
 
-    if (nCol1 == 0 && nCol2 == MAXCOL && mpRowHeights)
+    if (nCol1 == 0 && nCol2 == pDocument->MaxCol() && mpRowHeights)
     {
         mpRowHeights->setValue(nRow1, nRow2, pSrcTab->GetOriginalHeight(nSrcRow));
 
@@ -344,7 +344,7 @@ bool ScTable::IsEditActionAllowed(
     if (!IsProtected())
     {
         SCCOL nCol1 = 0, nCol2 = aCol.size() - 1;
-        SCROW nRow1 = 0, nRow2 = MAXROW;
+        SCROW nRow1 = 0, nRow2 = pDocument->MaxRow();
 
         switch (eAction)
         {
@@ -384,7 +384,7 @@ bool ScTable::IsEditActionAllowed(
         case sc::ColRowEditAction::InsertColumnsAfter:
         {
             // TODO: improve the matrix range handling for the insert-before action.
-            if (HasBlockMatrixFragment(nStart, 0, nEnd, MAXROW))
+            if (HasBlockMatrixFragment(nStart, 0, nEnd, pDocument->MaxRow()))
                 return false;
 
             return pTabProtection->isOptionEnabled(ScTableProtection::INSERT_COLUMNS);
@@ -393,7 +393,7 @@ bool ScTable::IsEditActionAllowed(
         case sc::ColRowEditAction::InsertRowsAfter:
         {
             // TODO: improve the matrix range handling for the insert-before action.
-            if (HasBlockMatrixFragment(0, nStart, MAXCOL, nEnd))
+            if (HasBlockMatrixFragment(0, nStart, pDocument->MaxCol(), nEnd))
                 return false;
 
             return pTabProtection->isOptionEnabled(ScTableProtection::INSERT_ROWS);
@@ -403,14 +403,14 @@ bool ScTable::IsEditActionAllowed(
             if (!pTabProtection->isOptionEnabled(ScTableProtection::DELETE_COLUMNS))
                 return false;
 
-            return !HasAttrib(nStart, 0, nEnd, MAXROW, HasAttrFlags::Protected);
+            return !HasAttrib(nStart, 0, nEnd, pDocument->MaxRow(), HasAttrFlags::Protected);
         }
         case sc::ColRowEditAction::DeleteRows:
         {
             if (!pTabProtection->isOptionEnabled(ScTableProtection::DELETE_ROWS))
                 return false;
 
-            return !HasAttrib(0, nStart, MAXCOL, nEnd, HasAttrFlags::Protected);
+            return !HasAttrib(0, nStart, pDocument->MaxCol(), nEnd, HasAttrFlags::Protected);
         }
         default:
             ;
@@ -456,9 +456,9 @@ void ScTable::finalizeOutlineImport()
 void ScTable::StoreToCache(SvStream& rStrm) const
 {
     SCCOL nStartCol = 0;
-    SCCOL nEndCol = MAXCOL;
+    SCCOL nEndCol = pDocument->MaxCol();
     SCROW nStartRow = 0;
-    SCROW nEndRow = MAXROW;
+    SCROW nEndRow = pDocument->MaxRow();
 
     GetDataArea(nStartCol, nStartRow, nEndCol, nEndRow, false, false);