[Libreoffice-commits] core.git: sc/inc sc/source

Caolán McNamara (via logerrit) logerrit at kemper.freedesktop.org
Wed Sep 16 12:23:04 UTC 2020


 sc/inc/table.hxx                       |    8 
 sc/source/core/data/documen2.cxx       |   12 -
 sc/source/core/data/document.cxx       |   20 +-
 sc/source/core/data/documentimport.cxx |    2 
 sc/source/core/data/table1.cxx         |  176 +++++++++----------
 sc/source/core/data/table2.cxx         |  300 ++++++++++++++++-----------------
 sc/source/core/data/table3.cxx         |   74 ++++----
 sc/source/core/data/table4.cxx         |   64 +++----
 sc/source/core/data/table5.cxx         |   40 ++--
 sc/source/core/data/table6.cxx         |   40 ++--
 sc/source/core/data/table7.cxx         |   18 -
 11 files changed, 377 insertions(+), 377 deletions(-)

New commits:
commit b979802fc92c8386fa35893f3c620082cec8fbde
Author:     Caolán McNamara <caolanm at redhat.com>
AuthorDate: Tue Sep 15 12:01:50 2020 +0100
Commit:     Caolán McNamara <caolanm at redhat.com>
CommitDate: Wed Sep 16 14:22:01 2020 +0200

    ScTable ctor never called with a null ScDocument*
    
    Change-Id: I183fd26df45ddd4e7432833c5c77b07b64e03609
    Reviewed-on: https://gerrit.libreoffice.org/c/core/+/102842
    Tested-by: Caolán McNamara <caolanm at redhat.com>
    Reviewed-by: Caolán McNamara <caolanm at redhat.com>

diff --git a/sc/inc/table.hxx b/sc/inc/table.hxx
index f938ea9009fb..3e15695567cd 100644
--- a/sc/inc/table.hxx
+++ b/sc/inc/table.hxx
@@ -199,7 +199,7 @@ private:
     mutable SCROW nTableAreaY;
 
     SCTAB           nTab;
-    ScDocument*     pDocument;
+    ScDocument&     rDocument;
     std::unique_ptr<utl::TextSearch> pSearchText;
 
     mutable OUString aUpperName;             // #i62977# filled only on demand, reset in SetName
@@ -266,14 +266,14 @@ friend class sc::EditTextIterator;
 friend class sc::FormulaGroupAreaListener;
 
 public:
-                ScTable( ScDocument* pDoc, SCTAB nNewTab, const OUString& rNewName,
+                ScTable( ScDocument& rDoc, SCTAB nNewTab, const OUString& rNewName,
                          bool bColInfo = true, bool bRowInfo = true );
                 ~ScTable() COVERITY_NOEXCEPT_FALSE;
                 ScTable(const ScTable&) = delete;
     ScTable&    operator=(const ScTable&) = delete;
 
-    ScDocument& GetDoc() { return *pDocument;}
-    const ScDocument& GetDoc() const { return *pDocument;}
+    ScDocument& GetDoc() { return rDocument;}
+    const ScDocument& GetDoc() const { return rDocument;}
     SCTAB GetTab() const { return nTab; }
 
     ScOutlineTable* GetOutlineTable()               { return pOutlineTable.get(); }
diff --git a/sc/source/core/data/documen2.cxx b/sc/source/core/data/documen2.cxx
index 3e08ae45a35d..6015aa596b55 100644
--- a/sc/source/core/data/documen2.cxx
+++ b/sc/source/core/data/documen2.cxx
@@ -495,7 +495,7 @@ void ScDocument::ResetClip( ScDocument* pSourceDoc, const ScMarkData* pMarks )
                     OUString aString = pSourceDoc->maTabs[i]->GetName();
                     if ( i < static_cast<SCTAB>(maTabs.size()) )
                     {
-                        maTabs[i].reset( new ScTable(this, i, aString) );
+                        maTabs[i].reset( new ScTable(*this, i, aString) );
 
                     }
                     else
@@ -504,7 +504,7 @@ void ScDocument::ResetClip( ScDocument* pSourceDoc, const ScMarkData* pMarks )
                         {
                             maTabs.resize(i);
                         }
-                        maTabs.emplace_back(new ScTable(this, i, aString));
+                        maTabs.emplace_back(new ScTable(*this, i, aString));
                     }
                     maTabs[i]->SetLayoutRTL( pSourceDoc->maTabs[i]->IsLayoutRTL() );
                 }
@@ -524,7 +524,7 @@ void ScDocument::ResetClip( ScDocument* pSourceDoc, SCTAB nTab )
         {
             maTabs.resize(nTab+1);
         }
-        maTabs[nTab].reset( new ScTable(this, nTab, "baeh") );
+        maTabs[nTab].reset( new ScTable(*this, nTab, "baeh") );
         if (nTab < static_cast<SCTAB>(pSourceDoc->maTabs.size()) && pSourceDoc->maTabs[nTab])
             maTabs[nTab]->SetLayoutRTL( pSourceDoc->maTabs[nTab]->IsLayoutRTL() );
     }
@@ -541,7 +541,7 @@ void ScDocument::EnsureTable( SCTAB nTab )
         maTabs.resize(nTab+1);
 
     if (!maTabs[nTab])
-        maTabs[nTab].reset( new ScTable(this, nTab, "temp", bExtras, bExtras) );
+        maTabs[nTab].reset( new ScTable(*this, nTab, "temp", bExtras, bExtras) );
 }
 
 ScRefCellValue ScDocument::GetRefCellValue( const ScAddress& rPos )
@@ -790,7 +790,7 @@ bool ScDocument::CopyTab( SCTAB nOldPos, SCTAB nNewPos, const ScMarkData* pOnlyM
         if (nNewPos >= static_cast<SCTAB>(maTabs.size()))
         {
             nNewPos = static_cast<SCTAB>(maTabs.size());
-            maTabs.emplace_back(new ScTable(this, nNewPos, aName));
+            maTabs.emplace_back(new ScTable(*this, nNewPos, aName));
         }
         else
         {
@@ -820,7 +820,7 @@ bool ScDocument::CopyTab( SCTAB nOldPos, SCTAB nNewPos, const ScMarkData* pOnlyM
                         (*it)->UpdateInsertTab(aCxt);
                 if (nNewPos <= nOldPos)
                     nOldPos++;
-                maTabs.emplace(maTabs.begin() + nNewPos, new ScTable(this, nNewPos, aName));
+                maTabs.emplace(maTabs.begin() + nNewPos, new ScTable(*this, nNewPos, aName));
                 bValid = true;
                 for (TableContainer::iterator it = maTabs.begin(); it != maTabs.end(); ++it)
                     if (*it && it != maTabs.begin()+nOldPos && it != maTabs.begin() + nNewPos)
diff --git a/sc/source/core/data/document.cxx b/sc/source/core/data/document.cxx
index 86fe8a318263..553b7e5f42af 100644
--- a/sc/source/core/data/document.cxx
+++ b/sc/source/core/data/document.cxx
@@ -177,13 +177,13 @@ void ScDocument::MakeTable( SCTAB nTab,bool _bNeedsNameCheck )
         CreateValidTabName( aString );  // no doubles
     if (nTab < static_cast<SCTAB>(maTabs.size()))
     {
-        maTabs[nTab].reset( new ScTable(this, nTab, aString) );
+        maTabs[nTab].reset( new ScTable(*this, nTab, aString) );
     }
     else
     {
         while(nTab > static_cast<SCTAB>(maTabs.size()))
             maTabs.push_back(nullptr);
-        maTabs.emplace_back( new ScTable(this, nTab, aString) );
+        maTabs.emplace_back( new ScTable(*this, nTab, aString) );
     }
     maTabs[nTab]->SetLoadingMedium(bLoadingMedium);
 }
@@ -478,7 +478,7 @@ void ScDocument::AppendTabOnLoad(const OUString& rName)
 
     OUString aName = rName;
     CreateValidTabName(aName);
-    maTabs.emplace_back( new ScTable(this, nTabCount, aName) );
+    maTabs.emplace_back( new ScTable(*this, nTabCount, aName) );
 }
 
 void ScDocument::SetTabNameOnLoad(SCTAB nTab, const OUString& rName)
@@ -513,7 +513,7 @@ bool ScDocument::InsertTab(
         if (nPos == SC_TAB_APPEND || nPos >= nTabCount)
         {
             nPos = maTabs.size();
-            maTabs.emplace_back( new ScTable(this, nTabCount, rName) );
+            maTabs.emplace_back( new ScTable(*this, nTabCount, rName) );
             if ( bExternalDocument )
                 maTabs[nTabCount]->SetVisible( false );
         }
@@ -544,7 +544,7 @@ bool ScDocument::InsertTab(
                     if (a)
                         a->UpdateInsertTab(aCxt);
                 }
-                maTabs.emplace(maTabs.begin() + nPos, new ScTable(this, nPos, rName));
+                maTabs.emplace(maTabs.begin() + nPos, new ScTable(*this, nPos, rName));
 
                 // UpdateBroadcastAreas must be called between UpdateInsertTab,
                 // which ends listening, and StartAllListeners, to not modify
@@ -602,7 +602,7 @@ bool ScDocument::InsertTabs( SCTAB nPos, const std::vector<OUString>& rNames,
         {
             for ( SCTAB i = 0; i < nNewSheets; ++i )
             {
-                maTabs.emplace_back( new ScTable(this, nTabCount + i, rNames.at(i)) );
+                maTabs.emplace_back( new ScTable(*this, nTabCount + i, rNames.at(i)) );
             }
         }
         else
@@ -633,7 +633,7 @@ bool ScDocument::InsertTabs( SCTAB nPos, const std::vector<OUString>& rNames,
                 }
                 for (SCTAB i = 0; i < nNewSheets; ++i)
                 {
-                    maTabs.emplace(maTabs.begin() + nPos + i, new ScTable(this, nPos + i, rNames.at(i)) );
+                    maTabs.emplace(maTabs.begin() + nPos + i, new ScTable(*this, nPos + i, rNames.at(i)) );
                 }
 
                 // UpdateBroadcastAreas must be called between UpdateInsertTab,
@@ -1987,7 +1987,7 @@ void ScDocument::InitUndoSelected( const ScDocument* pSrcDoc, const ScMarkData&
         for (SCTAB nTab = 0; nTab <= rTabSelection.GetLastSelected(); nTab++)
             if ( rTabSelection.GetTableSelect( nTab ) )
             {
-                ScTableUniquePtr pTable(new ScTable(this, nTab, OUString(), bColInfo, bRowInfo));
+                ScTableUniquePtr pTable(new ScTable(*this, nTab, OUString(), bColInfo, bRowInfo));
                 if (nTab < static_cast<SCTAB>(maTabs.size()))
                     maTabs[nTab] = std::move(pTable);
                 else
@@ -2028,7 +2028,7 @@ void ScDocument::InitUndo( const ScDocument* pSrcDoc, SCTAB nTab1, SCTAB nTab2,
         maTabs.resize(nTab2 + 1);
     for (SCTAB nTab = nTab1; nTab <= nTab2; nTab++)
     {
-        maTabs[nTab].reset(new ScTable(this, nTab, OUString(), bColInfo, bRowInfo));
+        maTabs[nTab].reset(new ScTable(*this, nTab, OUString(), bColInfo, bRowInfo));
     }
 }
 
@@ -2048,7 +2048,7 @@ void ScDocument::AddUndoTab( SCTAB nTab1, SCTAB nTab2, bool bColInfo, bool bRowI
     for (SCTAB nTab = nTab1; nTab <= nTab2; nTab++)
         if (!maTabs[nTab])
         {
-            maTabs[nTab].reset( new ScTable(this, nTab, OUString(), bColInfo, bRowInfo) );
+            maTabs[nTab].reset( new ScTable(*this, nTab, OUString(), bColInfo, bRowInfo) );
         }
 }
 
diff --git a/sc/source/core/data/documentimport.cxx b/sc/source/core/data/documentimport.cxx
index 224dfeacae6f..3b6a1e5315bf 100644
--- a/sc/source/core/data/documentimport.cxx
+++ b/sc/source/core/data/documentimport.cxx
@@ -163,7 +163,7 @@ bool ScDocumentImport::appendSheet(const OUString& rName)
     if (!ValidTab(nTabCount))
         return false;
 
-    mpImpl->mrDoc.maTabs.emplace_back(new ScTable(&mpImpl->mrDoc, nTabCount, rName));
+    mpImpl->mrDoc.maTabs.emplace_back(new ScTable(mpImpl->mrDoc, nTabCount, rName));
     return true;
 }
 
diff --git a/sc/source/core/data/table1.cxx b/sc/source/core/data/table1.cxx
index 9d70e081b1ae..331b5a7c3513 100644
--- a/sc/source/core/data/table1.cxx
+++ b/sc/source/core/data/table1.cxx
@@ -229,9 +229,9 @@ bool SetOptimalHeightsToRows(
 
 }
 
-ScTable::ScTable( ScDocument* pDoc, SCTAB nNewTab, const OUString& rNewName,
+ScTable::ScTable( ScDocument& rDoc, SCTAB nNewTab, const OUString& rNewName,
                     bool bColInfo, bool bRowInfo ) :
-    aCol( pDoc->GetSheetLimits(), INITIALCOLCOUNT ),
+    aCol( rDoc.GetSheetLimits(), INITIALCOLCOUNT ),
     aName( rNewName ),
     aCodeName( rNewName ),
     nLinkRefreshDelay( 0 ),
@@ -242,14 +242,14 @@ ScTable::ScTable( ScDocument* pDoc, SCTAB nNewTab, const OUString& rNewName,
     nRepeatStartY( SCROW_REPEAT_NONE ),
     nRepeatEndY( SCROW_REPEAT_NONE ),
     mpRowHeights( static_cast<ScFlatUInt16RowSegments*>(nullptr) ),
-    mpHiddenCols(new ScFlatBoolColSegments(pDoc->MaxCol())),
-    mpHiddenRows(new ScFlatBoolRowSegments(pDoc->MaxRow())),
-    mpFilteredCols(new ScFlatBoolColSegments(pDoc->MaxCol())),
-    mpFilteredRows(new ScFlatBoolRowSegments(pDoc->MaxRow())),
+    mpHiddenCols(new ScFlatBoolColSegments(rDoc.MaxCol())),
+    mpHiddenRows(new ScFlatBoolRowSegments(rDoc.MaxRow())),
+    mpFilteredCols(new ScFlatBoolColSegments(rDoc.MaxCol())),
+    mpFilteredRows(new ScFlatBoolRowSegments(rDoc.MaxRow())),
     nTableAreaX( 0 ),
     nTableAreaY( 0 ),
     nTab( nNewTab ),
-    pDocument( pDoc ),
+    rDocument( rDoc ),
     pSortCollator( nullptr ),
     nLockCount( 0 ),
     aScenarioColor( COL_LIGHTGRAY ),
@@ -271,46 +271,46 @@ ScTable::ScTable( ScDocument* pDoc, SCTAB nNewTab, const OUString& rNewName,
     bActiveScenario(false),
     mbPageBreaksValid(false),
     mbForceBreaks(false),
-    aDefaultColAttrArray(static_cast<SCCOL>(-1), nNewTab, pDoc, nullptr)
+    aDefaultColAttrArray(static_cast<SCCOL>(-1), nNewTab, &rDoc, nullptr)
 {
     if (bColInfo)
     {
-        mpColWidth.reset( new ScCompressedArray<SCCOL, sal_uInt16>( pDocument->MaxCol()+1, STD_COL_WIDTH ) );
-        mpColFlags.reset( new ScBitMaskCompressedArray<SCCOL, CRFlags>( pDocument->MaxCol()+1, CRFlags::NONE ) );
+        mpColWidth.reset( new ScCompressedArray<SCCOL, sal_uInt16>( rDocument.MaxCol()+1, STD_COL_WIDTH ) );
+        mpColFlags.reset( new ScBitMaskCompressedArray<SCCOL, CRFlags>( rDocument.MaxCol()+1, CRFlags::NONE ) );
     }
 
     if (bRowInfo)
     {
-        mpRowHeights.reset(new ScFlatUInt16RowSegments(pDocument->MaxRow(), ScGlobal::nStdRowHeight));
-        pRowFlags.reset(new ScBitMaskCompressedArray<SCROW, CRFlags>( pDocument->MaxRow(), CRFlags::NONE));
+        mpRowHeights.reset(new ScFlatUInt16RowSegments(rDocument.MaxRow(), ScGlobal::nStdRowHeight));
+        pRowFlags.reset(new ScBitMaskCompressedArray<SCROW, CRFlags>( rDocument.MaxRow(), CRFlags::NONE));
     }
 
-    if ( pDocument->IsDocVisible() )
+    if ( rDocument.IsDocVisible() )
     {
         //  when a sheet is added to a visible document,
         //  initialize its RTL flag from the system locale
         bLayoutRTL = ScGlobal::IsSystemRTL();
     }
 
-    ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer();
+    ScDrawLayer* pDrawLayer = rDocument.GetDrawLayer();
     if (pDrawLayer)
     {
         if ( pDrawLayer->ScAddPage( nTab ) )    // sal_False (not inserted) during Undo
         {
             pDrawLayer->ScRenamePage( nTab, aName );
-            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 );
+            sal_uLong const nx = sal_uLong(double(rDocument.MaxCol()+1) * STD_COL_WIDTH           * HMM_PER_TWIPS );
+            sal_uLong ny = static_cast<sal_uLong>(double(rDocument.MaxRow()+1) * ScGlobal::nStdRowHeight * HMM_PER_TWIPS );
             pDrawLayer->SetPageSize( static_cast<sal_uInt16>(nTab), Size( nx, ny ), false );
         }
     }
 
     for (SCCOL k=0; k < aCol.size(); k++)
-        aCol[k].Init( k, nTab, pDocument, true );
+        aCol[k].Init( k, nTab, &rDocument, true );
 }
 
 ScTable::~ScTable() COVERITY_NOEXCEPT_FALSE
 {
-    if (!pDocument->IsInDtorClear())
+    if (!rDocument.IsInDtorClear())
     {
         for (SCCOL nCol = 0; nCol < (aCol.size() - 1); ++nCol)
         {
@@ -320,7 +320,7 @@ ScTable::~ScTable() COVERITY_NOEXCEPT_FALSE
         //  (or else nTab does not reflect the page number!)
         //  In ScDocument::Clear is afterwards used from Clear at the Draw Layer to delete everything.
 
-        ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer();
+        ScDrawLayer* pDrawLayer = rDocument.GetDrawLayer();
         if (pDrawLayer)
             pDrawLayer->ScRemovePage( nTab );
     }
@@ -369,7 +369,7 @@ void ScTable::SetStreamValid( bool bSet, bool bIgnoreLock )
 {
     if (!bStreamValid && !bSet)
         return; // shortcut
-    if ( bIgnoreLock || !pDocument->IsStreamValidLocked() )
+    if ( bIgnoreLock || !rDocument.IsStreamValidLocked() )
         bStreamValid = bSet;
 }
 
@@ -456,14 +456,14 @@ bool ScTable::SetOptimalHeight(
     OSL_ENSURE( rCxt.getExtraHeight() == 0 || rCxt.isForceAutoSize(),
         "automatic OptimalHeight with Extra" );
 
-    if ( pDocument->IsAdjustHeightLocked() )
+    if ( rDocument.IsAdjustHeightLocked() )
     {
         return false;
     }
 
     SCSIZE  nCount = static_cast<SCSIZE>(nEndRow-nStartRow+1);
 
-    ScProgress* pProgress = GetProgressBar(nCount, GetWeightedCount(), pOuterProgress, pDocument);
+    ScProgress* pProgress = GetProgressBar(nCount, GetWeightedCount(), pOuterProgress, &rDocument);
 
     mpRowHeights->enableTreeSearch(false);
 
@@ -487,12 +487,12 @@ void ScTable::SetOptimalHeightOnly(
     OSL_ENSURE( rCxt.getExtraHeight() == 0 || rCxt.isForceAutoSize(),
         "automatic OptimalHeight with Extra" );
 
-    if ( pDocument->IsAdjustHeightLocked() )
+    if ( rDocument.IsAdjustHeightLocked() )
         return;
 
     SCSIZE  nCount = static_cast<SCSIZE>(nEndRow-nStartRow+1);
 
-    ScProgress* pProgress = GetProgressBar(nCount, GetWeightedCount(), pOuterProgress, pDocument);
+    ScProgress* pProgress = GetProgressBar(nCount, GetWeightedCount(), pOuterProgress, &rDocument);
 
     GetOptimalHeightsInColumn(rCxt, aCol, nStartRow, nEndRow, pProgress, nProgressStart);
 
@@ -603,7 +603,7 @@ bool ScTable::GetPrintArea( SCCOL& rEndCol, SCROW& rEndRow, bool bNotes ) const
         }
     }
 
-    if (nMaxX == pDocument->MaxCol())                    // omit attribute at the right
+    if (nMaxX == rDocument.MaxCol())                    // omit attribute at the right
     {
         --nMaxX;
         while ( nMaxX>0 && aCol[nMaxX].IsVisibleAttrEqual(aCol[nMaxX+1]) )
@@ -658,7 +658,7 @@ bool ScTable::GetPrintAreaHor( SCROW nStartRow, SCROW nEndRow,
         }
     }
 
-    if (nMaxX == pDocument->MaxCol())                    // omit attribute at the right
+    if (nMaxX == rDocument.MaxCol())                    // omit attribute at the right
     {
         --nMaxX;
         while ( nMaxX>0 && aCol[nMaxX].IsVisibleAttrEqual(aCol[nMaxX+1], nStartRow, nEndRow) )
@@ -727,7 +727,7 @@ bool ScTable::GetDataStart( SCCOL& rStartCol, SCROW& rStartRow ) const
 {
     bool bFound = false;
     SCCOL nMinX = aCol.size()-1;
-    SCROW nMinY = pDocument->MaxRow();
+    SCROW nMinY = rDocument.MaxRow();
     SCCOL i;
 
     for (i=0; i<aCol.size(); i++)                   // Test attribute
@@ -819,7 +819,7 @@ void ScTable::GetDataArea( SCCOL& rStartCol, SCROW& rStartRow, SCCOL& rEndCol, S
             SCROW nStart = rStartRow;
             SCROW nEnd = rEndRow;
             if (nStart>0) --nStart;
-            if (nEnd<pDocument->MaxRow()) ++nEnd;
+            if (nEnd<rDocument.MaxRow()) ++nEnd;
 
             if (rEndCol < (aCol.size()-1))
                 if (!aCol[rEndCol+1].IsEmptyBlock(nStart,nEnd))
@@ -856,7 +856,7 @@ void ScTable::GetDataArea( SCCOL& rStartCol, SCROW& rStartRow, SCCOL& rEndCol, S
             }
         }
 
-        if (rEndRow < pDocument->MaxRow())
+        if (rEndRow < rDocument.MaxRow())
         {
             SCROW nTest = rEndRow+1;
             bool needExtend = false;
@@ -883,7 +883,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 < pDocument->MaxRow() && rStartRow < rEndRow )
+        if ( !bTop && rStartRow < rDocument.MaxRow() && rStartRow < rEndRow )
         {
             bool bShrink = true;
             do
@@ -893,7 +893,7 @@ void ScTable::GetDataArea( SCCOL& rStartCol, SCROW& rStartRow, SCCOL& rEndCol, S
                         bShrink = false;
                 if (bShrink)
                     ++rStartRow;
-            } while (bShrink && rStartRow < pDocument->MaxRow() && rStartRow < rEndRow);
+            } while (bShrink && rStartRow < rDocument.MaxRow() && rStartRow < rEndRow);
         }
     }
 
@@ -975,9 +975,9 @@ bool ScTable::ShrinkToUsedDataArea( bool& o_bShrunk, SCCOL& rStartCol, SCROW& rS
         rEndCol = aCol.size()-1;
         o_bShrunk = true;
     }
-    if (rEndRow > pDocument->MaxRow())
+    if (rEndRow > rDocument.MaxRow())
     {
-        rEndRow = pDocument->MaxRow();
+        rEndRow = rDocument.MaxRow();
         o_bShrunk = true;
     }
 
@@ -1173,17 +1173,17 @@ SCCOL ScTable::FindNextVisibleCol( SCCOL nCol, bool bRight ) const
     {
         nCol++;
         SCCOL nEnd = 0;
-        bool bHidden = pDocument->ColHidden(nCol, nTab, nullptr, &nEnd);
+        bool bHidden = rDocument.ColHidden(nCol, nTab, nullptr, &nEnd);
         if(bHidden)
             nCol = nEnd +1;
 
-        return std::min<SCCOL>(pDocument->MaxCol(), nCol);
+        return std::min<SCCOL>(rDocument.MaxCol(), nCol);
     }
     else
     {
         nCol--;
-        SCCOL nStart = pDocument->MaxCol();
-        bool bHidden = pDocument->ColHidden(nCol, nTab, &nStart);
+        SCCOL nStart = rDocument.MaxCol();
+        bool bHidden = rDocument.ColHidden(nCol, nTab, &nStart);
         if(bHidden)
             nCol = nStart - 1;
 
@@ -1197,22 +1197,22 @@ 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 pDocument->MaxCol().
+        // To maintain the original return behaviour, return rDocument.MaxCol().
         if(nCol >= nLastCol)
-            return pDocument->MaxCol();
+            return rDocument.MaxCol();
 
         do
         {
             nCol++;
             SCCOL nEndCol = 0;
-            bool bHidden = pDocument->ColHidden( nCol, nTab, nullptr, &nEndCol );
+            bool bHidden = rDocument.ColHidden( nCol, nTab, nullptr, &nEndCol );
             if(bHidden)
             {
                 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 pDocument->MaxCol().
+                // For nCol == nLastCol, it may still have data so don't want to return rDocument.MaxCol().
                 if(nCol > nLastCol)
-                    return pDocument->MaxCol();
+                    return rDocument.MaxCol();
             }
 
             if(aCol[nCol].HasVisibleDataAt(nRow))
@@ -1220,11 +1220,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 pDocument->MaxCol();
+        return rDocument.MaxCol();
     }
     else
     {
-        // If nCol is in the unallocated range [nLastCol+1, pDocument->MaxCol()], then move it directly to nLastCol
+        // If nCol is in the unallocated range [nLastCol+1, rDocument.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 )
@@ -1236,8 +1236,8 @@ SCCOL ScTable::FindNextVisibleColWithContent( SCCOL nCol, bool bRight, SCROW nRo
         do
         {
             nCol--;
-            SCCOL nStartCol = pDocument->MaxCol();
-            bool bHidden = pDocument->ColHidden( nCol, nTab, &nStartCol );
+            SCCOL nStartCol = rDocument.MaxCol();
+            bool bHidden = rDocument.ColHidden( nCol, nTab, &nStartCol );
             if(bHidden)
             {
                 nCol = nStartCol -1;
@@ -1265,7 +1265,7 @@ void ScTable::FindAreaPos( SCCOL& rCol, SCROW& rRow, ScMoveDirection eDirection
         bool bRight = (eDirection == SC_MOVE_RIGHT);
         if (bThere)
         {
-            if(nNewCol >= pDocument->MaxCol() && eDirection == SC_MOVE_RIGHT)
+            if(nNewCol >= rDocument.MaxCol() && eDirection == SC_MOVE_RIGHT)
                 return;
             else if(nNewCol == 0 && eDirection == SC_MOVE_LEFT)
                 return;
@@ -1284,7 +1284,7 @@ void ScTable::FindAreaPos( SCCOL& rCol, SCROW& rRow, ScMoveDirection eDirection
                     else
                         bFound = true;
                 }
-                while(!bFound && nNextCol > 0 && nNextCol < pDocument->MaxCol());
+                while(!bFound && nNextCol > 0 && nNextCol < rDocument.MaxCol());
             }
             else
             {
@@ -1298,8 +1298,8 @@ void ScTable::FindAreaPos( SCCOL& rCol, SCROW& rRow, ScMoveDirection eDirection
 
         if (nNewCol<0)
             nNewCol=0;
-        if (nNewCol>pDocument->MaxCol())
-            nNewCol=pDocument->MaxCol();
+        if (nNewCol>rDocument.MaxCol())
+            nNewCol=rDocument.MaxCol();
         rCol = nNewCol;
     }
     else
@@ -1309,9 +1309,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 pDocument->MaxRow() depending on eDirection to maintain the behaviour of
+            // Set rRow to 0 or rDocument.MaxRow() depending on eDirection to maintain the behaviour of
             // ScColumn::FindDataAreaPos() when the given column is empty.
-            rRow = ( eDirection == SC_MOVE_DOWN ) ? pDocument->MaxRow() : 0;
+            rRow = ( eDirection == SC_MOVE_DOWN ) ? rDocument.MaxRow() : 0;
         }
     }
 }
@@ -1322,7 +1322,7 @@ bool ScTable::ValidNextPos( SCCOL nCol, SCROW nRow, const ScMarkData& rMark,
     if (!ValidCol(nCol) || !ValidRow(nRow))
         return false;
 
-    if (pDocument->HasAttrib(nCol, nRow, nTab, nCol, nRow, nTab, HasAttrFlags::Overlapped))
+    if (rDocument.HasAttrib(nCol, nRow, nTab, nCol, nRow, nTab, HasAttrFlags::Overlapped))
         // Skip an overlapped cell.
         return false;
 
@@ -1332,7 +1332,7 @@ bool ScTable::ValidNextPos( SCCOL nCol, SCROW nRow, const ScMarkData& rMark,
     /* TODO: for cursor movement *only* this should even take the protection
      * options (select locked, select unlocked) into account, see
      * ScTabView::SkipCursorHorizontal() and ScTabView::SkipCursorVertical(). */
-    if (bUnprotected && pDocument->HasAttrib(nCol, nRow, nTab, nCol, nRow, nTab, HasAttrFlags::Protected))
+    if (bUnprotected && rDocument.HasAttrib(nCol, nRow, nTab, nCol, nRow, nTab, HasAttrFlags::Protected))
         return false;
 
     if (bMarked || bUnprotected)        //TODO: also in other case ???
@@ -1359,10 +1359,10 @@ bool ScTable::SkipRow( const SCCOL nCol, SCROW& rRow, const SCROW nMovY,
     if ( !ValidRow( rRow ))
         return false;
 
-    if (bSheetProtected && pDocument->HasAttrib( nCol, rRow, nTab, nCol, rRow, nTab, HasAttrFlags::Protected))
+    if (bSheetProtected && rDocument.HasAttrib( nCol, rRow, nTab, nCol, rRow, nTab, HasAttrFlags::Protected))
     {
         if ( rRow > nUsedY )
-            rRow = (bUp ? nUsedY : pDocument->MaxRow() + nMovY);
+            rRow = (bUp ? nUsedY : rDocument.MaxRow() + nMovY);
         else
             rRow += nMovY;
 
@@ -1374,7 +1374,7 @@ bool ScTable::SkipRow( const SCCOL nCol, SCROW& rRow, const SCROW nMovY,
     else
     {
         bool bRowHidden  = RowHidden( rRow );
-        bool bOverlapped = pDocument->HasAttrib( nCol, rRow, nTab, nCol, rRow, nTab, HasAttrFlags::Overlapped );
+        bool bOverlapped = rDocument.HasAttrib( nCol, rRow, nTab, nCol, rRow, nTab, HasAttrFlags::Overlapped );
 
         if ( bRowHidden || bOverlapped )
         {
@@ -1433,13 +1433,13 @@ void ScTable::GetNextPos( SCCOL& rCol, SCROW& rRow, SCCOL nMovX, SCROW nMovY,
         nStartRow = 0;
         nEndCol = rCol;
         nEndRow = rRow;
-        pDocument->GetPrintArea( nTab, nEndCol, nEndRow, true );
+        rDocument.GetPrintArea( nTab, nEndCol, nEndRow, true );
         // Add some cols/rows to the print area (which is "content or
         // 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, pDocument->MaxCol());
-        nEndRow = std::min<SCROW>( nEndRow+42, pDocument->MaxRow());
+        nEndCol = std::min<SCCOL>( nEndCol+42, rDocument.MaxCol());
+        nEndRow = std::min<SCROW>( nEndRow+42, rDocument.MaxRow());
     }
     else
     {
@@ -1641,10 +1641,10 @@ bool ScTable::GetNextMarkedCell( SCCOL& rCol, SCROW& rRow, const ScMarkData& rMa
     while ( rCol < aCol.size() )
     {
         ScMarkArray aArray( rMark.GetMarkArray( rCol ) );
-        while ( rRow <= pDocument->MaxRow() )
+        while ( rRow <= rDocument.MaxRow() )
         {
             SCROW nStart = aArray.GetNextMarked( rRow, false );
-            if ( nStart <= pDocument->MaxRow() )
+            if ( nStart <= rDocument.MaxRow() )
             {
                 SCROW nEnd = aArray.GetMarkEnd( nStart, false );
 
@@ -1660,7 +1660,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 = pDocument->MaxRow() + 1;
+                        rRow = rDocument.MaxRow() + 1;
                         continue;
                     }
                 }
@@ -1675,14 +1675,14 @@ bool ScTable::GetNextMarkedCell( SCCOL& rCol, SCROW& rRow, const ScMarkData& rMa
                 rRow = nEnd + 1;                // Search for next selected range
             }
             else
-                rRow = pDocument->MaxRow() + 1;              // End of column
+                rRow = rDocument.MaxRow() + 1;              // End of column
         }
         rRow = 0;
         ++rCol;                                 // test next column
     }
 
-    // Though searched only the allocated columns, it is equivalent to a search till pDocument->MaxCol().
-    rCol = pDocument->MaxCol() + 1;
+    // Though searched only the allocated columns, it is equivalent to a search till rDocument.MaxCol().
+    rCol = rDocument.MaxCol() + 1;
     return false;                               // Through all columns
 }
 
@@ -1693,7 +1693,7 @@ void ScTable::UpdateDrawRef( UpdateRefMode eUpdateRefMode, SCCOL nCol1, SCROW nR
     if ( !(nTab >= nTab1 && nTab <= nTab2 && nDz == 0) )       // only within the table
         return;
 
-    ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer();
+    ScDrawLayer* pDrawLayer = rDocument.GetDrawLayer();
     if ( eUpdateRefMode != URM_COPY && pDrawLayer )
     {
         if ( eUpdateRefMode == URM_MOVE )
@@ -1722,7 +1722,7 @@ void ScTable::UpdateReference(
     else
     {
         i = 0;
-        iMax = pDocument->MaxCol();
+        iMax = rDocument.MaxCol();
     }
 
     UpdateRefMode eUpdateRefMode = rCxt.meMode;
@@ -1761,7 +1761,7 @@ void ScTable::UpdateReference(
             nERow = rPrintRange.aEnd.Row();
 
             // do not try to modify sheet index of print range
-            if ( ScRefUpdate::Update( pDocument, eUpdateRefMode,
+            if ( ScRefUpdate::Update( &rDocument, eUpdateRefMode,
                                       nCol1,nRow1,nTab, nCol2,nRow2,nTab,
                                       nDx,nDy,0,
                                       nSCol,nSRow,nSTab, nECol,nERow,nETab ) )
@@ -1779,7 +1779,7 @@ void ScTable::UpdateReference(
             nERow = pRepeatColRange->aEnd.Row();
 
             // do not try to modify sheet index of repeat range
-            if ( ScRefUpdate::Update( pDocument, eUpdateRefMode,
+            if ( ScRefUpdate::Update( &rDocument, eUpdateRefMode,
                                       nCol1,nRow1,nTab, nCol2,nRow2,nTab,
                                       nDx,nDy,0,
                                       nSCol,nSRow,nSTab, nECol,nERow,nETab ) )
@@ -1799,7 +1799,7 @@ void ScTable::UpdateReference(
             nERow = pRepeatRowRange->aEnd.Row();
 
             // do not try to modify sheet index of repeat range
-            if ( ScRefUpdate::Update( pDocument, eUpdateRefMode,
+            if ( ScRefUpdate::Update( &rDocument, eUpdateRefMode,
                                       nCol1,nRow1,nTab, nCol2,nRow2,nTab,
                                       nDx,nDy,0,
                                       nSCol,nSRow,nSTab, nECol,nERow,nETab ) )
@@ -1816,7 +1816,7 @@ void ScTable::UpdateReference(
         {
             UpdatePageBreaks(nullptr);
 
-            pDocument->RepaintRange( ScRange(0,0,nTab,pDocument->MaxCol(),pDocument->MaxRow(),nTab) );
+            rDocument.RepaintRange( ScRange(0,0,nTab,rDocument.MaxCol(),rDocument.MaxRow(),nTab) );
         }
     }
 
@@ -1827,7 +1827,7 @@ void ScTable::UpdateReference(
         mpCondFormatList->UpdateReference(rCxt);
 
     if (pTabProtection)
-        pTabProtection->updateReference( eUpdateRefMode, pDocument, rCxt.maRange, nDx, nDy, nDz);
+        pTabProtection->updateReference( eUpdateRefMode, &rDocument, rCxt.maRange, nDx, nDy, nDz);
 }
 
 void ScTable::UpdateTranspose( const ScRange& rSource, const ScAddress& rDest,
@@ -1862,8 +1862,8 @@ void ScTable::UpdateInsertTab( sc::RefUpdateInsertTabContext& rCxt )
         mpCondFormatList->UpdateInsertTab(rCxt);
 
     if (pTabProtection)
-        pTabProtection->updateReference( URM_INSDEL, pDocument,
-                ScRange( 0, 0, rCxt.mnInsertPos, pDocument->MaxCol(), pDocument->MaxRow(), MAXTAB),
+        pTabProtection->updateReference( URM_INSDEL, &rDocument,
+                ScRange( 0, 0, rCxt.mnInsertPos, rDocument.MaxCol(), rDocument.MaxRow(), MAXTAB),
                 0, 0, rCxt.mnSheets);
 
     for (SCCOL i=0; i < aCol.size(); i++)
@@ -1891,8 +1891,8 @@ void ScTable::UpdateDeleteTab( sc::RefUpdateDeleteTabContext& rCxt )
         mpCondFormatList->UpdateDeleteTab(rCxt);
 
     if (pTabProtection)
-        pTabProtection->updateReference( URM_INSDEL, pDocument,
-                ScRange( 0, 0, rCxt.mnDeletePos, pDocument->MaxCol(), pDocument->MaxRow(), MAXTAB),
+        pTabProtection->updateReference( URM_INSDEL, &rDocument,
+                ScRange( 0, 0, rCxt.mnDeletePos, rDocument.MaxCol(), rDocument.MaxRow(), MAXTAB),
                 0, 0, -rCxt.mnSheets);
 
     for (SCCOL i = 0; i < aCol.size(); ++i)
@@ -1915,8 +1915,8 @@ void ScTable::UpdateMoveTab(
         mpCondFormatList->UpdateMoveTab(rCxt);
 
     if (pTabProtection)
-        pTabProtection->updateReference( URM_REORDER, pDocument,
-                ScRange( 0, 0, rCxt.mnOldPos, pDocument->MaxCol(), pDocument->MaxRow(), MAXTAB),
+        pTabProtection->updateReference( URM_REORDER, &rDocument,
+                ScRange( 0, 0, rCxt.mnOldPos, rDocument.MaxCol(), rDocument.MaxRow(), MAXTAB),
                 0, 0, rCxt.mnNewPos - rCxt.mnOldPos);
 
     for ( SCCOL i=0; i < aCol.size(); i++ )
@@ -1966,9 +1966,9 @@ void ScTable::ExtendPrintArea( OutputDevice* pDev,
 
     // First, mark those columns that we need to skip i.e. hidden and empty columns.
 
-    ScFlatBoolColSegments aSkipCols(pDocument->MaxCol());
-    aSkipCols.setFalse(0, pDocument->MaxCol());
-    for (SCCOL i = 0; i <= pDocument->MaxCol(); ++i)
+    ScFlatBoolColSegments aSkipCols(rDocument.MaxCol());
+    aSkipCols.setFalse(0, rDocument.MaxCol());
+    for (SCCOL i = 0; i <= rDocument.MaxCol(); ++i)
     {
         SCCOL nLastCol = i;
         if (ColHidden(i, nullptr, &nLastCol))
@@ -1983,7 +1983,7 @@ void ScTable::ExtendPrintArea( OutputDevice* pDev,
             {
                 if ( j >= aCol.size() )
                 {
-                    aSkipCols.setTrue( j, pDocument->MaxCol() );
+                    aSkipCols.setTrue( j, rDocument.MaxCol() );
                     break;
                 }
                 if (aCol[j].GetCellCount() == 0)
@@ -2012,7 +2012,7 @@ void ScTable::ExtendPrintArea( OutputDevice* pDev,
         for (SCCOL nDataCol = nCol; 0 <= nDataCol && nDataCol >= aColData.mnCol1; --nDataCol)
         {
             SCCOL nPrintCol = nDataCol;
-            VisibleDataCellIterator aIter(pDocument, *mpHiddenRows, aCol[nDataCol]);
+            VisibleDataCellIterator aIter(&rDocument, *mpHiddenRows, aCol[nDataCol]);
             ScRefCellValue aCell = aIter.reset(nStartRow);
             if (aCell.isEmpty())
                 // No visible cells found in this column.  Skip it.
@@ -2085,7 +2085,7 @@ void ScTable::MaybeAddExtraColumn(SCCOL& rCol, SCROW nRow, OutputDevice* pDev, d
         //  look at alignment
 
         const ScPatternAttr* pPattern = GetPattern( rCol, nRow );
-        const SfxItemSet* pCondSet = pDocument->GetCondResult( rCol, nRow, nTab );
+        const SfxItemSet* pCondSet = rDocument.GetCondResult( rCol, nRow, nTab );
 
         SvxCellHorJustify eHorJust =
                         pPattern->GetItem( ATTR_HOR_JUSTIFY, pCondSet ).GetValue();
@@ -2103,7 +2103,7 @@ void ScTable::MaybeAddExtraColumn(SCCOL& rCol, SCROW nRow, OutputDevice* pDev, d
     }
 
     SCCOL nNewCol = rCol;
-    while (nMissing > 0 && nNewCol < pDocument->MaxCol())
+    while (nMissing > 0 && nNewCol < rDocument.MaxCol())
     {
         auto nNextCol = nNewCol + 1;
         bool bNextEmpty = true;
@@ -2617,8 +2617,8 @@ void ScTable::CreateColumnIfNotExistsImpl( const SCCOL nScCol ) const
     // which is bad since that code is not thread-safe.
     SolarMutexGuard aGuard;
     const SCCOL aOldColSize = aCol.size();
-    aCol.resize( pDocument->GetSheetLimits(), static_cast< size_t >( nScCol + 1 ) );
+    aCol.resize( rDocument.GetSheetLimits(), static_cast< size_t >( nScCol + 1 ) );
     for (SCCOL i = aOldColSize; i <= nScCol; i++)
-        aCol[i].Init( i, nTab, pDocument, false );
+        aCol[i].Init( i, nTab, &rDocument, false );
 }
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sc/source/core/data/table2.cxx b/sc/source/core/data/table2.cxx
index e625fb037feb..a5ecf2b228f9 100644
--- a/sc/source/core/data/table2.cxx
+++ b/sc/source/core/data/table2.cxx
@@ -134,7 +134,7 @@ bool ScTable::TestInsertRow( SCCOL nStartCol, SCCOL nEndCol, SCROW nStartRow, SC
 {
     bool bTest = true;
 
-    if ( nStartCol==0 && nEndCol==pDocument->MaxCol() && pOutlineTable )
+    if ( nStartCol==0 && nEndCol==rDocument.MaxCol() && pOutlineTable )
         bTest = pOutlineTable->TestInsertRow(nSize);
 
     for (SCCOL i=nStartCol; (i<=nEndCol) && bTest; i++)
@@ -145,7 +145,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==pDocument->MaxCol())
+    if (nStartCol==0 && nEndCol==rDocument.MaxCol())
     {
         if (mpRowHeights && pRowFlags)
         {
@@ -195,7 +195,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==pDocument->MaxCol())
+    if (nStartCol==0 && nEndCol==rDocument.MaxCol())
     {
         if (pRowFlags)
             pRowFlags->Remove( nStartRow, nSize);
@@ -232,7 +232,7 @@ void ScTable::DeleteRow(
     }
 
     {   // scope for bulk broadcast
-        ScBulkBroadcast aBulkBroadcast( pDocument->GetBASM(), SfxHintId::ScDataChanged);
+        ScBulkBroadcast aBulkBroadcast( rDocument.GetBASM(), SfxHintId::ScDataChanged);
         for (SCCOL j=nStartCol; j<=nEndCol; j++)
             aCol[j].DeleteRow(nStartRow, nSize, pGroupPos);
     }
@@ -251,14 +251,14 @@ void ScTable::DeleteRow(
 
 bool ScTable::TestInsertCol( SCROW nStartRow, SCROW nEndRow, SCSIZE nSize ) const
 {
-    if ( nSize > o3tl::make_unsigned(pDocument->MaxCol()) )
+    if ( nSize > o3tl::make_unsigned(rDocument.MaxCol()) )
         return false;
 
-    if ( nStartRow==0 && nEndRow==pDocument->MaxRow() && pOutlineTable
+    if ( nStartRow==0 && nEndRow==rDocument.MaxRow() && pOutlineTable
         && ! pOutlineTable->TestInsertCol(nSize) )
             return false;
 
-    auto range = GetColumnsRange( pDocument->MaxCol() - static_cast<SCCOL>(nSize) + 1, pDocument->MaxCol() );
+    auto range = GetColumnsRange( rDocument.MaxCol() - static_cast<SCCOL>(nSize) + 1, rDocument.MaxCol() );
     for (auto it = range.rbegin(); it != range.rend(); ++it )
         if (! aCol[*it].TestInsertCol(nStartRow, nEndRow))
             return false;
@@ -269,13 +269,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==pDocument->MaxRow())
+    if (nStartRow==0 && nEndRow==rDocument.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(pDocument->MaxCol()-nSize-nStartCol, nSize); ++i)
+            for (SCSIZE i=0; i < std::min(rDocument.MaxCol()-nSize-nStartCol, nSize); ++i)
                 mpColWidth->SetValue(nStartCol + i, mpColWidth->GetValue(nStartCol+i+nSize));
             mpColFlags->InsertPreservingSize(nStartCol, nSize, CRFlags::NONE);
         }
@@ -301,7 +301,7 @@ void ScTable::InsertCol(
         }
     }
 
-    if ((nStartRow == 0) && (nEndRow == pDocument->MaxRow()))
+    if ((nStartRow == 0) && (nEndRow == rDocument.MaxRow()))
     {
         for (SCSIZE i=0; i < nSize; i++)
             for (SCCOL nCol = aCol.size() - 1; nCol > nStartCol; nCol--)
@@ -323,7 +323,7 @@ void ScTable::InsertCol(
         nWhichArray[0] = ATTR_MERGE;
         nWhichArray[1] = 0;
 
-        sc::CopyToDocContext aCxt(*pDocument);
+        sc::CopyToDocContext aCxt(rDocument);
         for (SCSIZE i=0; i<nSize; i++)
         {
             aCol[nStartCol-1].CopyToColumn(aCxt, nStartRow, nEndRow, InsertDeleteFlags::ATTRIB,
@@ -346,11 +346,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==pDocument->MaxRow())
+    if (nStartRow==0 && nEndRow==rDocument.MaxRow())
     {
         if (mpColWidth && mpColFlags)
         {
-            assert( nStartCol + nSize <= o3tl::make_unsigned(pDocument->MaxCol()+1) );    // moving 0 if ==pDocument->MaxCol()+1 is correct
+            assert( nStartCol + nSize <= o3tl::make_unsigned(rDocument.MaxCol()+1) );    // moving 0 if ==rDocument.MaxCol()+1 is correct
             mpColWidth->RemovePreservingSize(nStartCol, nSize, STD_COL_WIDTH);
             mpColFlags->RemovePreservingSize(nStartCol, nSize, CRFlags::NONE);
         }
@@ -386,7 +386,7 @@ void ScTable::DeleteCol(
     for (SCSIZE i = 0; i < nSize; i++)
         aCol[nStartCol + i].DeleteArea(nStartRow, nEndRow, InsertDeleteFlags::ALL, false);
 
-    if ((nStartRow == 0) && (nEndRow == pDocument->MaxRow()))
+    if ((nStartRow == 0) && (nEndRow == rDocument.MaxRow()))
     {
         for (SCSIZE i=0; i < nSize; i++)
             for (SCCOL nCol = nStartCol; nCol < aCol.size() - 1; nCol++)
@@ -414,11 +414,11 @@ void ScTable::DeleteArea(
     bool bBroadcast, sc::ColumnSpanSet* pBroadcastSpans )
 {
     if ( nCol2 >= aCol.size() ) nCol2 = aCol.size() - 1;
-    if (nRow2 > pDocument->MaxRow()) nRow2 = pDocument->MaxRow();
+    if (nRow2 > rDocument.MaxRow()) nRow2 = rDocument.MaxRow();
     if (ValidColRow(nCol1, nRow1) && ValidColRow(nCol2, nRow2))
     {
         {   // scope for bulk broadcast
-            ScBulkBroadcast aBulkBroadcast( pDocument->GetBASM(), SfxHintId::ScDataChanged);
+            ScBulkBroadcast aBulkBroadcast( rDocument.GetBASM(), SfxHintId::ScDataChanged);
             for (SCCOL i = nCol1; i <= nCol2; i++)
                 aCol[i].DeleteArea(nRow1, nRow2, nDelFlag, bBroadcast, pBroadcastSpans);
         }
@@ -427,7 +427,7 @@ void ScTable::DeleteArea(
 
         if ( IsProtected() && (nDelFlag & InsertDeleteFlags::ATTRIB) )
         {
-            ScPatternAttr aPattern(pDocument->GetPool());
+            ScPatternAttr aPattern(rDocument.GetPool());
             aPattern.GetItemSet().Put( ScProtectionAttr( false ) );
             ApplyPatternArea( nCol1, nRow1, nCol2, nRow2, aPattern );
         }
@@ -444,7 +444,7 @@ void ScTable::DeleteArea(
 void ScTable::DeleteSelection( InsertDeleteFlags nDelFlag, const ScMarkData& rMark, bool bBroadcast )
 {
     {   // scope for bulk broadcast
-        ScBulkBroadcast aBulkBroadcast( pDocument->GetBASM(), SfxHintId::ScDataChanged);
+        ScBulkBroadcast aBulkBroadcast( rDocument.GetBASM(), SfxHintId::ScDataChanged);
         for (SCCOL i=0; i < aCol.size(); i++)
             aCol[i].DeleteSelection(nDelFlag, rMark, bBroadcast);
     }
@@ -464,7 +464,7 @@ void ScTable::DeleteSelection( InsertDeleteFlags nDelFlag, const ScMarkData& rMa
 
     if ( IsProtected() && (nDelFlag & InsertDeleteFlags::ATTRIB) )
     {
-        ScDocumentPool* pPool = pDocument->GetPool();
+        ScDocumentPool* pPool = rDocument.GetPool();
         SfxItemSet aSet( *pPool, svl::Items<ATTR_PATTERN_START, ATTR_PATTERN_END>{} );
         aSet.Put( ScProtectionAttr( false ) );
         SfxItemPoolCache aCache( pPool, &aSet );
@@ -520,7 +520,7 @@ void ScTable::CopyToClip(
         for (SCCOL i = nCol1; i <= nCol2; i++)
             pTable->aCol[i].RemoveProtected(nRow1, nRow2);
 
-    pTable->mpCondFormatList.reset(new ScConditionalFormatList(pTable->pDocument, *mpCondFormatList));
+    pTable->mpCondFormatList.reset(new ScConditionalFormatList(&pTable->rDocument, *mpCondFormatList));
 }
 
 void ScTable::CopyToClip(
@@ -560,7 +560,7 @@ void ScTable::CopyStaticToDocument(
         for (SCROW nRow = nRow1; nRow <= nRow2; ++nRow)
         {
             sal_uInt32 nNumFmt = aDefaultColAttrArray.GetPattern(nRow)->GetNumberFormat(
-                pDocument->GetNonThreadedContext().GetFormatTable());
+                rDocument.GetNonThreadedContext().GetFormatTable());
             SvNumberFormatterMergeMap::const_iterator itNum = rMap.find(nNumFmt);
             if (itNum != rMap.end())
                 nNumFmt = itNum->second;
@@ -623,7 +623,7 @@ void ScTable::CopyConditionalFormat( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCRO
 {
     ScRange aOldRange( nCol1 - nDx, nRow1 - nDy, pTable->nTab, nCol2 - nDx, nRow2 - nDy, pTable->nTab);
     ScRange aNewRange( nCol1, nRow1, nTab, nCol2, nRow2, nTab );
-    bool bSameDoc = pDocument->GetStyleSheetPool() == pTable->pDocument->GetStyleSheetPool();
+    bool bSameDoc = rDocument.GetStyleSheetPool() == pTable->rDocument.GetStyleSheetPool();
 
     for(const auto& rxCondFormat : *pTable->mpCondFormatList)
     {
@@ -632,10 +632,10 @@ void ScTable::CopyConditionalFormat( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCRO
             continue;
 
         ScRangeList aIntersectedRange = rCondFormatRange.GetIntersectedRange(aOldRange);
-        std::unique_ptr<ScConditionalFormat> pNewFormat = rxCondFormat->Clone(pDocument);
+        std::unique_ptr<ScConditionalFormat> pNewFormat = rxCondFormat->Clone(&rDocument);
 
         pNewFormat->SetRange(aIntersectedRange);
-        sc::RefUpdateContext aRefCxt(*pDocument);
+        sc::RefUpdateContext aRefCxt(rDocument);
         aRefCxt.meMode = URM_COPY;
         aRefCxt.maRange = aNewRange;
         aRefCxt.mnColDelta = nDx;
@@ -643,7 +643,7 @@ void ScTable::CopyConditionalFormat( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCRO
         aRefCxt.mnTabDelta = nTab - pTable->nTab;
         pNewFormat->UpdateReference(aRefCxt, true);
 
-        if (bSameDoc && pTable->nTab == nTab && CheckAndDeduplicateCondFormat(pDocument, mpCondFormatList->GetFormat(rxCondFormat->GetKey()), pNewFormat.get(), nTab))
+        if (bSameDoc && pTable->nTab == nTab && CheckAndDeduplicateCondFormat(&rDocument, mpCondFormatList->GetFormat(rxCondFormat->GetKey()), pNewFormat.get(), nTab))
         {
             continue;
         }
@@ -653,7 +653,7 @@ void ScTable::CopyConditionalFormat( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCRO
         {
             // Check if there is the same format in the destination
             // If there is, then simply expand its range
-            if (CheckAndDeduplicateCondFormat(pDocument, rxCond.get(), pNewFormat.get(), nTab))
+            if (CheckAndDeduplicateCondFormat(&rDocument, rxCond.get(), pNewFormat.get(), nTab))
             {
                 bDuplicate = true;
                 break;
@@ -687,16 +687,16 @@ void ScTable::CopyConditionalFormat( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCRO
 
                 if(!aStyleName.isEmpty())
                 {
-                    if(pDocument->GetStyleSheetPool()->Find(aStyleName, SfxStyleFamily::Para))
+                    if(rDocument.GetStyleSheetPool()->Find(aStyleName, SfxStyleFamily::Para))
                         continue;
 
-                    pDocument->GetStyleSheetPool()->CopyStyleFrom(
-                            pTable->pDocument->GetStyleSheetPool(), aStyleName, SfxStyleFamily::Para );
+                    rDocument.GetStyleSheetPool()->CopyStyleFrom(
+                            pTable->rDocument.GetStyleSheetPool(), aStyleName, SfxStyleFamily::Para );
                 }
             }
         }
 
-        pDocument->AddCondFormatData( pNewFormatTmp->GetRange(), nTab, pNewFormatTmp->GetKey() );
+        rDocument.AddCondFormatData( pNewFormatTmp->GetRange(), nTab, pNewFormatTmp->GetKey() );
     }
 }
 
@@ -715,10 +715,10 @@ void ScTable::CopyFromClip(
     sc::CopyFromClipContext& rCxt, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
     SCCOL nDx, SCROW nDy, ScTable* pTable )
 {
-    if (nCol2 > pDocument->MaxCol())
-        nCol2 = pDocument->MaxCol();
-    if (nRow2 > pDocument->MaxRow())
-        nRow2 = pDocument->MaxRow();
+    if (nCol2 > rDocument.MaxCol())
+        nCol2 = rDocument.MaxCol();
+    if (nRow2 > rDocument.MaxRow())
+        nRow2 = rDocument.MaxRow();
 
     if (!(ValidColRow(nCol1, nRow1) && ValidColRow(nCol2, nRow2)))
         return;
@@ -743,10 +743,10 @@ void ScTable::CopyFromClip(
     if ((rCxt.getInsertFlag() & InsertDeleteFlags::ATTRIB) == InsertDeleteFlags::NONE)
         return;
 
-    if (nRow1==0 && nRow2==pDocument->MaxRow() && mpColWidth && pTable->mpColWidth)
+    if (nRow1==0 && nRow2==rDocument.MaxRow() && mpColWidth && pTable->mpColWidth)
         mpColWidth->CopyFrom(*pTable->mpColWidth, nCol1, nCol2, nCol1 - nDx);
 
-    if (nCol1==0 && nCol2==pDocument->MaxCol() && mpRowHeights && pTable->mpRowHeights &&
+    if (nCol1==0 && nCol2==rDocument.MaxCol() && mpRowHeights && pTable->mpRowHeights &&
                                      pRowFlags && pTable->pRowFlags)
     {
         CopyRowHeight(*pTable, nRow1, nRow2, -nDy);
@@ -763,7 +763,7 @@ void ScTable::CopyFromClip(
     // Do not set protected cell in a protected sheet
     if (IsProtected() && (rCxt.getInsertFlag() & InsertDeleteFlags::ATTRIB))
     {
-        ScPatternAttr aPattern(pDocument->GetPool());
+        ScPatternAttr aPattern(rDocument.GetPool());
         aPattern.GetItemSet().Put( ScProtectionAttr( false ) );
         ApplyPatternArea( nCol1, nRow1, nCol2, nRow2, aPattern );
     }
@@ -893,9 +893,9 @@ public:
 void ScTable::TransposeClip( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
                                 ScTable* pTransClip, InsertDeleteFlags nFlags, bool bAsLink )
 {
-    bool bWasCut = pDocument->IsCutMode();
+    bool bWasCut = rDocument.IsCutMode();
 
-    ScDocument* pDestDoc = pTransClip->pDocument;
+    ScDocument& rDestDoc = pTransClip->rDocument;
 
     for (SCCOL nCol=nCol1; nCol<=nCol2; nCol++)
     {
@@ -912,12 +912,12 @@ void ScTable::TransposeClip( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
                 ScSingleRefData aRef;
                 aRef.InitAddress(ScAddress(nCol,nRow,nTab));
                 aRef.SetFlag3D(true);
-                ScTokenArray aArr(*pDestDoc);
+                ScTokenArray aArr(rDestDoc);
                 aArr.AddSingleReference( aRef );
 
                 pTransClip->SetFormulaCell(
                     static_cast<SCCOL>(nRow-nRow1), static_cast<SCROW>(nCol-nCol1),
-                    new ScFormulaCell(pDestDoc, aDestPos, aArr));
+                    new ScFormulaCell(&rDestDoc, aDestPos, aArr));
             }
         }
         else
@@ -971,10 +971,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>(pDocument->MaxCol()+1 - (nAttrRow2-nRow1))),
+                                        static_cast<SCCOL>(rDocument.MaxCol()+1 - (nAttrRow2-nRow1))),
                                     std::min(
                                         static_cast<SCROW>(rOldMerge.GetColMerge()),
-                                        static_cast<SCROW>(pDocument->MaxRow()+1 - (nCol-nCol1)))));
+                                        static_cast<SCROW>(rDocument.MaxRow()+1 - (nCol-nCol1)))));
                     const ScMergeFlagAttr& rOldFlag = rSet.Get(ATTR_MERGE_FLAG);
                     if (rOldFlag.IsOverlapped())
                     {
@@ -993,7 +993,7 @@ void ScTable::TransposeClip( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,
         }
 
         // Cell Notes - fdo#68381 paste cell notes on Transpose
-        if ( pDocument->HasColNotes(nCol, nTab) )
+        if ( rDocument.HasColNotes(nCol, nTab) )
             TransposeColNotes(pTransClip, nCol1, nCol, nRow1, nRow2);
     }
 }
@@ -1043,12 +1043,12 @@ void ScTable::TransposeColNotes(ScTable* pTransClip, SCCOL nCol1, SCCOL nCol, SC
                 for (; itData != itDataEnd; ++itData, ++curRow)
                 {
                     ScAddress aDestPos( static_cast<SCCOL>(curRow-nRow1), static_cast<SCROW>(nCol-nCol1), pTransClip->nTab );
-                    pTransClip->pDocument->ReleaseNote(aDestPos);
+                    pTransClip->rDocument.ReleaseNote(aDestPos);
                     ScPostIt* pNote = *itData;
                     if (pNote)
                     {
-                        std::unique_ptr<ScPostIt> pClonedNote = pNote->Clone( ScAddress(nCol, curRow, nTab), *pTransClip->pDocument, aDestPos, true );
-                        pTransClip->pDocument->SetNote(aDestPos, std::move(pClonedNote));
+                        std::unique_ptr<ScPostIt> pClonedNote = pNote->Clone( ScAddress(nCol, curRow, nTab), pTransClip->rDocument, aDestPos, true );
+                        pTransClip->rDocument.SetNote(aDestPos, std::move(pClonedNote));
                     }
                 }
                 break; // we reached the last valid block
@@ -1060,12 +1060,12 @@ void ScTable::TransposeColNotes(ScTable* pTransClip, SCCOL nCol1, SCCOL nCol, SC
                 for (; itData != itDataEnd; ++itData, ++curRow)
                 {
                     ScAddress aDestPos( static_cast<SCCOL>(curRow-nRow1), static_cast<SCROW>(nCol-nCol1), pTransClip->nTab );
-                    pTransClip->pDocument->ReleaseNote(aDestPos);
+                    pTransClip->rDocument.ReleaseNote(aDestPos);
                     ScPostIt* pNote = *itData;
                     if (pNote)
                     {
-                        std::unique_ptr<ScPostIt> pClonedNote = pNote->Clone( ScAddress(nCol, curRow, nTab), *pTransClip->pDocument, aDestPos, true );
-                        pTransClip->pDocument->SetNote(aDestPos, std::move(pClonedNote));
+                        std::unique_ptr<ScPostIt> pClonedNote = pNote->Clone( ScAddress(nCol, curRow, nTab), pTransClip->rDocument, aDestPos, true );
+                        pTransClip->rDocument.SetNote(aDestPos, std::move(pClonedNote));
                     }
                 }
             }
@@ -1076,7 +1076,7 @@ void ScTable::TransposeColNotes(ScTable* pTransClip, SCCOL nCol1, SCCOL nCol, SC
             for ( curRow = nBlockStart + nOffsetInBlock; curRow <= nBlockEnd && curRow <= nRowPos; ++curRow)
             {
                 ScAddress aDestPos( static_cast<SCCOL>(curRow-nRow1), static_cast<SCROW>(nCol-nCol1), pTransClip->nTab );
-                pTransClip->pDocument->ReleaseNote(aDestPos);
+                pTransClip->rDocument.ReleaseNote(aDestPos);
             }
             if (curRow == nRowPos)
                 break;
@@ -1140,8 +1140,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 > pDocument->MaxCol()) nCol2 = pDocument->MaxCol();
-    if (nRow2 > pDocument->MaxRow()) nRow2 = pDocument->MaxRow();
+    if (nCol2 > rDocument.MaxCol()) nCol2 = rDocument.MaxCol();
+    if (nRow2 > rDocument.MaxRow()) nRow2 = rDocument.MaxRow();
     if (ValidColRow(nCol1, nRow1) && ValidColRow(nCol2, nRow2))
         for (SCCOL i = nCol1; i <= nCol2; i++)
             aCol[i].SetDirtyFromClip(nRow1, nRow2, rBroadcastSpans);
@@ -1152,8 +1152,8 @@ void ScTable::StartListeningFormulaCells(
     SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 )
 {
     if ( nCol2 >= aCol.size() ) nCol2 = aCol.size() - 1;
-    if (nCol2 > pDocument->MaxCol()) nCol2 = pDocument->MaxCol();
-    if (nRow2 > pDocument->MaxRow()) nRow2 = pDocument->MaxRow();
+    if (nCol2 > rDocument.MaxCol()) nCol2 = rDocument.MaxCol();
+    if (nRow2 > rDocument.MaxRow()) nRow2 = rDocument.MaxRow();
     if (ValidColRow(nCol1, nRow1) && ValidColRow(nCol2, nRow2))
         for (SCCOL i = nCol1; i <= nCol2; i++)
             aCol[i].StartListeningFormulaCells(rStartCxt, rEndCxt, nRow1, nRow2);
@@ -1167,7 +1167,7 @@ void ScTable::CopyToTable(
     if (!ValidColRow(nCol1, nRow1) || !ValidColRow(nCol2, nRow2))
         return;
 
-    bool bIsUndoDoc = pDestTab->pDocument->IsUndo();
+    bool bIsUndoDoc = pDestTab->rDocument.IsUndo();
 
     if (bIsUndoDoc && (nFlags & InsertDeleteFlags::CONTENTS))
     {
@@ -1183,7 +1183,7 @@ void ScTable::CopyToTable(
         // tdf#102364 - in some pathological cases CopyToTable() replacing cells with new cells
         // can lead to repetitive splitting and rejoining of the same formula group, which can get
         // quadratically expensive with large groups. So do the grouping just once at the end.
-        sc::DelayFormulaGroupingSwitch delayGrouping( *pDestTab->pDocument, true );
+        sc::DelayFormulaGroupingSwitch delayGrouping( pDestTab->rDocument, true );
         for (SCCOL i = nCol1; i <= ClampToAllocatedColumns(nCol2); i++)
             aCol[i].CopyToColumn(rCxt, nRow1, nRow2, bIsUndoDoc ? nFlags : nTempFlags, bMarked,
                                  pDestTab->CreateColumnIfNotExists(i), pMarkData, bAsLink, bGlobalNamesToLocal);
@@ -1194,7 +1194,7 @@ void ScTable::CopyToTable(
 
     if(bIsUndoDoc && (nFlags & InsertDeleteFlags::ATTRIB))
     {
-        pDestTab->mpCondFormatList.reset(new ScConditionalFormatList(pDestTab->pDocument, *mpCondFormatList));
+        pDestTab->mpCondFormatList.reset(new ScConditionalFormatList(&pDestTab->rDocument, *mpCondFormatList));
     }
 
     if (pDBDataNoName)
@@ -1208,12 +1208,12 @@ void ScTable::CopyToTable(
         pDestTab->SetAnonymousDBData(std::move(pNewDBData));
     }
     //  Charts have to be adjusted when hide/show
-    ScChartListenerCollection* pCharts = pDestTab->pDocument->GetChartListenerCollection();
+    ScChartListenerCollection* pCharts = pDestTab->rDocument.GetChartListenerCollection();
 
     bool bFlagChange = false;
 
-    bool bWidth  = (nRow1==0 && nRow2==pDocument->MaxRow() && mpColWidth && pDestTab->mpColWidth);
-    bool bHeight = (nCol1==0 && nCol2==pDocument->MaxCol() && mpRowHeights && pDestTab->mpRowHeights);
+    bool bWidth  = (nRow1==0 && nRow2==rDocument.MaxRow() && mpColWidth && pDestTab->mpColWidth);
+    bool bHeight = (nCol1==0 && nCol2==rDocument.MaxCol() && mpRowHeights && pDestTab->mpRowHeights);
 
     if (bWidth || bHeight)
     {
@@ -1231,7 +1231,7 @@ void ScTable::CopyToTable(
                 pDestTab->SetColHidden(i, i, bThisHidden);
                 //TODO: collect changes?
                 if (bHiddenChange && pCharts)
-                    pCharts->SetRangeDirty(ScRange( i, 0, nTab, i, pDocument->MaxRow(), nTab ));
+                    pCharts->SetRangeDirty(ScRange( i, 0, nTab, i, rDocument.MaxRow(), nTab ));
 
                 if (bChange)
                     bFlagChange = true;
@@ -1264,7 +1264,7 @@ void ScTable::CopyToTable(
                 bool bHiddenChanged = pDestTab->SetRowHidden(i, nLastRow, bHidden);
                 if (bHiddenChanged && pCharts)
                     // Hidden flags differ.
-                    pCharts->SetRangeDirty(ScRange(0, i, nTab, pDocument->MaxCol(), nLastRow, nTab));
+                    pCharts->SetRangeDirty(ScRange(0, i, nTab, rDocument.MaxCol(), nLastRow, nTab));
 
                 if (bHiddenChanged)
                     bFlagChange = true;
@@ -1328,8 +1328,8 @@ void ScTable::UndoToTable(
     if (!(ValidColRow(nCol1, nRow1) && ValidColRow(nCol2, nRow2)))
         return;
 
-    bool bWidth  = (nRow1==0 && nRow2==pDocument->MaxRow() && mpColWidth && pDestTab->mpColWidth);
-    bool bHeight = (nCol1==0 && nCol2==pDocument->MaxCol() && mpRowHeights && pDestTab->mpRowHeights);
+    bool bWidth  = (nRow1==0 && nRow2==rDocument.MaxRow() && mpColWidth && pDestTab->mpColWidth);
+    bool bHeight = (nCol1==0 && nCol2==rDocument.MaxCol() && mpRowHeights && pDestTab->mpRowHeights);
 
     if ((nFlags & InsertDeleteFlags::CONTENTS) && mpRangeName)
     {
@@ -1337,9 +1337,9 @@ void ScTable::UndoToTable(
         // formulas. If mpRangeName is not set then the Undo wasn't even
         // set to an empty ScRangeName map so don't "undo" that.
         pDestTab->SetRangeName( std::unique_ptr<ScRangeName>( new ScRangeName( *GetRangeName())));
-        if (!pDestTab->pDocument->IsClipOrUndo())
+        if (!pDestTab->rDocument.IsClipOrUndo())
         {
-            ScDocShell* pDocSh = static_cast<ScDocShell*>(pDestTab->pDocument->GetDocumentShell());
+            ScDocShell* pDocSh = static_cast<ScDocShell*>(pDestTab->rDocument.GetDocumentShell());
             if (pDocSh)
                 pDocSh->SetAreasChangedNeedBroadcast();
         }
@@ -1352,11 +1352,11 @@ void ScTable::UndoToTable(
         if ( i >= nCol1 && i <= nCol2 )
             aCol[i].UndoToColumn(rCxt, nRow1, nRow2, nFlags, bMarked, rDestCol);
         else
-            aCol[i].CopyToColumn(rCxt, 0, pDocument->MaxRow(), InsertDeleteFlags::FORMULA, false, rDestCol);
+            aCol[i].CopyToColumn(rCxt, 0, rDocument.MaxRow(), InsertDeleteFlags::FORMULA, false, rDestCol);
     }
 
     if (nFlags & InsertDeleteFlags::ATTRIB)
-        pDestTab->mpCondFormatList.reset(new ScConditionalFormatList(pDestTab->pDocument, *mpCondFormatList));
+        pDestTab->mpCondFormatList.reset(new ScConditionalFormatList(&pDestTab->rDocument, *mpCondFormatList));
 
     if (!(bWidth||bHeight))
         return;
@@ -1455,7 +1455,7 @@ const ScRangeList* ScTable::GetScenarioRanges() const
     if (!pScenarioRanges)
     {
         const_cast<ScTable*>(this)->pScenarioRanges.reset(new ScRangeList);
-        ScMarkData aMark(pDocument->GetSheetLimits());
+        ScMarkData aMark(rDocument.GetSheetLimits());
         MarkScenarioIn( aMark, ScScenarioFlags::NONE );     // always
         aMark.FillRangeListWithMarks( pScenarioRanges.get(), false );
     }
@@ -1484,7 +1484,7 @@ bool ScTable::SetString( SCCOL nCol, SCROW nRow, SCTAB nTabP, const OUString& rS
     }
 
     return CreateColumnIfNotExists(nCol).SetString(
-        nRow, nTabP, rString, pDocument->GetAddressConvention(), pParam);
+        nRow, nTabP, rString, rDocument.GetAddressConvention(), pParam);
 }
 
 bool ScTable::SetEditText( SCCOL nCol, SCROW nRow, std::unique_ptr<EditTextObject> pEditText )
@@ -1515,7 +1515,7 @@ SCROW ScTable::GetFirstEditTextRow( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW
         return -1;
 
     nCol2 = ClampToAllocatedColumns(nCol2);
-    SCROW nFirst = pDocument->MaxRow()+1;
+    SCROW nFirst = rDocument.MaxRow()+1;
     for (SCCOL i = nCol1; i <= nCol2; ++i)
     {
         const ScColumn& rCol = aCol[i];
@@ -1530,7 +1530,7 @@ SCROW ScTable::GetFirstEditTextRow( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW
         }
     }
 
-    return nFirst == (pDocument->MaxRow()+1) ? -1 : nFirst;
+    return nFirst == (rDocument.MaxRow()+1) ? -1 : nFirst;
 }
 
 void ScTable::SetEmptyCell( SCCOL nCol, SCROW nRow )
@@ -1731,19 +1731,19 @@ CommentCaptionState ScTable::GetAllNoteCaptionsState(const ScRange& rRange, std:
     bool bIsFirstNoteShownState = true; // because of error: -Werror=maybe-uninitialized
     bool bFirstControl = true;
 
-    ScTable* pTab = pDocument->FetchTable(nTab);
+    ScTable* pTab = rDocument.FetchTable(nTab);
     assert(pTab);
     const SCCOL nEndCol = pTab->ClampToAllocatedColumns(rRange.aEnd.Col());
     for (SCCOL nCol = rRange.aStart.Col(); nCol <= nEndCol; ++nCol)
     {
-        if (bFirstControl && pDocument->HasColNotes(nCol, nTab)) // detect status of first note caption
+        if (bFirstControl && rDocument.HasColNotes(nCol, nTab)) // detect status of first note caption
         {
             aCol[nCol].GetNotesInRange(nStartRow, nEndRow, rNotes);
             bIsFirstNoteShownState = rNotes.begin()->mpNote->IsCaptionShown();
             bFirstControl = false;
         }
 
-        if (pDocument->HasColNotes(nCol, nTab))
+        if (rDocument.HasColNotes(nCol, nTab))
         {
             aCol[nCol].GetNotesInRange(nStartRow, nEndRow, rNotes);
 
@@ -1760,7 +1760,7 @@ CommentCaptionState ScTable::GetAllNoteCaptionsState(const ScRange& rRange, std:
 void ScTable::GetUnprotectedCells( ScRangeList& rRangeList ) const
 {
     for (auto const & pCol : aCol)
-        pCol->GetUnprotectedCells(0, pDocument->MaxRow(), rRangeList);
+        pCol->GetUnprotectedCells(0, rDocument.MaxRow(), rRangeList);
 }
 
 bool ScTable::ContainsNotesInRange( const ScRange& rRange ) const
@@ -1796,7 +1796,7 @@ ScRefCellValue ScTable::GetCellValue( SCCOL nCol, SCROW nRow ) const
 void ScTable::GetFirstDataPos(SCCOL& rCol, SCROW& rRow) const
 {
     rCol = 0;
-    rRow = pDocument->MaxRow()+1;
+    rRow = rDocument.MaxRow()+1;
     while (rCol < (aCol.size() - 1) && aCol[rCol].IsEmptyData() )
         ++rCol;
     SCCOL nCol = rCol;
@@ -1815,7 +1815,7 @@ void ScTable::GetLastDataPos(SCCOL& rCol, SCROW& rRow) const
     while (aCol[rCol].IsEmptyData() && (rCol > 0))
         rCol--;
     SCCOL nCol = rCol;
-    while (nCol >= 0 && rRow < pDocument->MaxRow())
+    while (nCol >= 0 && rRow < rDocument.MaxRow())
         rRow = ::std::max( rRow, aCol[nCol--].GetLastDataPos());
 }
 
@@ -1865,7 +1865,7 @@ void ScTable::SetDirtyVar()
 
 void ScTable::CheckVectorizationState()
 {
-    sc::AutoCalcSwitch aACSwitch(*pDocument, false);
+    sc::AutoCalcSwitch aACSwitch(rDocument, false);
 
     for (SCCOL i = 0; i < aCol.size(); i++)
         aCol[i].CheckVectorizationState();
@@ -1873,7 +1873,7 @@ void ScTable::CheckVectorizationState()
 
 void ScTable::SetAllFormulasDirty( const sc::SetFormulaDirtyContext& rCxt )
 {
-    sc::AutoCalcSwitch aACSwitch(*pDocument, false);
+    sc::AutoCalcSwitch aACSwitch(rDocument, false);
 
     for (SCCOL i=0; i < aCol.size(); i++)
         aCol[i].SetAllFormulasDirty(rCxt);
@@ -1881,46 +1881,46 @@ void ScTable::SetAllFormulasDirty( const sc::SetFormulaDirtyContext& rCxt )
 
 void ScTable::SetDirty( const ScRange& rRange, ScColumn::BroadcastMode eMode )
 {
-    bool bOldAutoCalc = pDocument->GetAutoCalc();
-    pDocument->SetAutoCalc( false );    // avoid multiple recalculations
+    bool bOldAutoCalc = rDocument.GetAutoCalc();
+    rDocument.SetAutoCalc( false );    // avoid multiple recalculations
     SCCOL nCol2 = rRange.aEnd.Col();
     nCol2 = ClampToAllocatedColumns(nCol2);
     for (SCCOL i=rRange.aStart.Col(); i<=nCol2; i++)
         aCol[i].SetDirty(rRange.aStart.Row(), rRange.aEnd.Row(), eMode);
-    pDocument->SetAutoCalc( bOldAutoCalc );
+    rDocument.SetAutoCalc( bOldAutoCalc );
 }
 
 void ScTable::SetTableOpDirty( const ScRange& rRange )
 {
-    bool bOldAutoCalc = pDocument->GetAutoCalc();
-    pDocument->SetAutoCalc( false );    // no multiple recalculation
+    bool bOldAutoCalc = rDocument.GetAutoCalc();
+    rDocument.SetAutoCalc( false );    // no multiple recalculation
     const SCCOL nCol2 = ClampToAllocatedColumns(rRange.aEnd.Col());
     for (SCCOL i=rRange.aStart.Col(); i<=nCol2; i++)
         aCol[i].SetTableOpDirty( rRange );
-    pDocument->SetAutoCalc( bOldAutoCalc );
+    rDocument.SetAutoCalc( bOldAutoCalc );
 }
 
 void ScTable::SetDirtyAfterLoad()
 {
-    bool bOldAutoCalc = pDocument->GetAutoCalc();
-    pDocument->SetAutoCalc( false );    // avoid multiple recalculations
+    bool bOldAutoCalc = rDocument.GetAutoCalc();
+    rDocument.SetAutoCalc( false );    // avoid multiple recalculations
     for (SCCOL i=0; i < aCol.size(); i++)
         aCol[i].SetDirtyAfterLoad();
-    pDocument->SetAutoCalc( bOldAutoCalc );
+    rDocument.SetAutoCalc( bOldAutoCalc );
 }
 
 void ScTable::SetDirtyIfPostponed()
 {
-    bool bOldAutoCalc = pDocument->GetAutoCalc();
-    pDocument->SetAutoCalc( false );    // avoid multiple recalculations
+    bool bOldAutoCalc = rDocument.GetAutoCalc();
+    rDocument.SetAutoCalc( false );    // avoid multiple recalculations
     for (SCCOL i=0; i < aCol.size(); i++)
         aCol[i].SetDirtyIfPostponed();
-    pDocument->SetAutoCalc( bOldAutoCalc );
+    rDocument.SetAutoCalc( bOldAutoCalc );
 }
 
 void ScTable::BroadcastRecalcOnRefMove()
 {
-    sc::AutoCalcSwitch aSwitch(*pDocument, false);
+    sc::AutoCalcSwitch aSwitch(rDocument, false);
     for (SCCOL i = 0; i < aCol.size(); ++i)
         aCol[i].BroadcastRecalcOnRefMove();
 }
@@ -1928,7 +1928,7 @@ void ScTable::BroadcastRecalcOnRefMove()
 bool ScTable::BroadcastBroadcasters( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, ScHint& rHint )
 {
     bool bBroadcasted = false;
-    sc::AutoCalcSwitch aSwitch(*pDocument, false);
+    sc::AutoCalcSwitch aSwitch(rDocument, false);
     rHint.GetAddress().SetTab(nTab);
     nCol2 = ClampToAllocatedColumns(nCol2);
     for (SCCOL nCol = nCol1; nCol <= nCol2; ++nCol)
@@ -2026,7 +2026,7 @@ sal_uInt32 ScTable::GetNumberFormat( const ScInterpreterContext& rContext, const
 sal_uInt32 ScTable::GetNumberFormat( SCCOL nCol, SCROW nRow ) const
 {
     if (ValidColRow(nCol,nRow))
-        return CreateColumnIfNotExists(nCol).GetNumberFormat(pDocument->GetNonThreadedContext(), nRow);
+        return CreateColumnIfNotExists(nCol).GetNumberFormat(rDocument.GetNonThreadedContext(), nRow);
     else
         return 0;
 }
@@ -2054,7 +2054,7 @@ const ScPatternAttr* ScTable::GetPattern( SCCOL nCol, SCROW nRow ) const
     else
     {
         OSL_FAIL("wrong column or row");
-        return pDocument->GetDefPattern();      // for safety
+        return rDocument.GetDefPattern();      // for safety
     }
 }
 
@@ -2234,12 +2234,12 @@ 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, pDocument->MaxCol()))
+    for (SCCOL nCol : GetColumnsRange(0, rDocument.MaxCol()))
     {
         if (!ColHidden(nCol))
         {
             SCSIZE nArrY = 0;
-            ScDocAttrIterator aIter( pDocument, nTab, nCol, nY1, nCol, nY2 );
+            ScDocAttrIterator aIter( &rDocument, nTab, nCol, nY1, nCol, nY2 );
             SCCOL nAttrCol;
             SCROW nAttrRow1, nAttrRow2;
             const ScPatternAttr* pPattern = aIter.GetNext( nAttrCol, nAttrRow1, nAttrRow2 );
@@ -2253,7 +2253,7 @@ void ScTable::FindMaxRotCol( RowInfo* pRowInfo, SCSIZE nArrCount, SCCOL nX1, SCC
                     //  handled individually
 
                     const ScCondFormatIndexes& rCondFormatData = static_cast<const ScCondFormatItem*>(pCondItem)->GetCondFormatData();
-                    ScStyleSheetPool* pStylePool = pDocument->GetStyleSheetPool();
+                    ScStyleSheetPool* pStylePool = rDocument.GetStyleSheetPool();
                     if (mpCondFormatList && pStylePool && !rCondFormatData.empty())
                     {
                         for(const auto& rItem : rCondFormatData)
@@ -2427,7 +2427,7 @@ bool ScTable::IsBlockEditable( SCCOL nCol1, SCROW nRow1, SCCOL nCol2,
     bool bIsEditable = true;
     if ( nLockCount )
         bIsEditable = false;
-    else if ( IsProtected() && !pDocument->IsScenario(nTab) )
+    else if ( IsProtected() && !rDocument.IsScenario(nTab) )
     {
         bIsEditable = !HasAttrib( nCol1, nRow1, nCol2, nRow2, HasAttrFlags::Protected );
         if (!bIsEditable)
@@ -2443,13 +2443,13 @@ bool ScTable::IsBlockEditable( SCCOL nCol1, SCROW nRow1, SCCOL nCol2,
             // on the active scenario range. Note the 'copy back' must also
             // be set to apply protection.
             sal_uInt16 nScenTab = nTab+1;
-            while(pDocument->IsScenario(nScenTab))
+            while(rDocument.IsScenario(nScenTab))
             {
                 ScRange aEditRange(nCol1, nRow1, nScenTab, nCol2, nRow2, nScenTab);
-                if(pDocument->IsActiveScenario(nScenTab) && pDocument->HasScenarioRange(nScenTab, aEditRange))
+                if(rDocument.IsActiveScenario(nScenTab) && rDocument.HasScenarioRange(nScenTab, aEditRange))
                 {
                     ScScenarioFlags nFlags;
-                    pDocument->GetScenarioFlags(nScenTab,nFlags);
+                    rDocument.GetScenarioFlags(nScenTab,nFlags);
                     bIsEditable = !((nFlags & ScScenarioFlags::Protected) && (nFlags & ScScenarioFlags::TwoWay));
                     break;
                 }
@@ -2457,7 +2457,7 @@ bool ScTable::IsBlockEditable( SCCOL nCol1, SCROW nRow1, SCCOL nCol2,
             }
         }
     }
-    else if (pDocument->IsScenario(nTab))
+    else if (rDocument.IsScenario(nTab))
     {
         // Determine if the preceding sheet is protected
         SCTAB nActualTab = nTab;
@@ -2465,15 +2465,15 @@ bool ScTable::IsBlockEditable( SCCOL nCol1, SCROW nRow1, SCCOL nCol2,
         {
             nActualTab--;
         }
-        while(pDocument->IsScenario(nActualTab));
+        while(rDocument.IsScenario(nActualTab));
 
-        if(pDocument->IsTabProtected(nActualTab))
+        if(rDocument.IsTabProtected(nActualTab))
         {
             ScRange aEditRange(nCol1, nRow1, nTab, nCol2, nRow2, nTab);
-            if(pDocument->HasScenarioRange(nTab, aEditRange))
+            if(rDocument.HasScenarioRange(nTab, aEditRange))
             {
                 ScScenarioFlags nFlags;
-                pDocument->GetScenarioFlags(nTab,nFlags);
+                rDocument.GetScenarioFlags(nTab,nFlags);
                 bIsEditable = !(nFlags & ScScenarioFlags::Protected);
             }
         }
@@ -2500,7 +2500,7 @@ bool ScTable::IsSelectionEditable( const ScMarkData& rMark,
     bool bIsEditable = true;
     if ( nLockCount )
         bIsEditable = false;
-    else if ( IsProtected() && !pDocument->IsScenario(nTab) )
+    else if ( IsProtected() && !rDocument.IsScenario(nTab) )
     {
         ScRangeList aRanges;
         rMark.FillRangeListWithMarks( &aRanges, false );
@@ -2517,17 +2517,17 @@ bool ScTable::IsSelectionEditable( const ScMarkData& rMark,
             // check the active scenario protect flag if this area is
             // in the active scenario range.
             SCTAB nScenTab = nTab+1;
-            while(pDocument->IsScenario(nScenTab) && bIsEditable)
+            while(rDocument.IsScenario(nScenTab) && bIsEditable)
             {
-                if(pDocument->IsActiveScenario(nScenTab))
+                if(rDocument.IsActiveScenario(nScenTab))
                 {
                     for (size_t i=0, nRange = aRanges.size(); (i < nRange) && bIsEditable; i++ )
                     {
                         const ScRange & rRange = aRanges[ i ];
-                        if(pDocument->HasScenarioRange(nScenTab, rRange))
+                        if(rDocument.HasScenarioRange(nScenTab, rRange))
                         {
                             ScScenarioFlags nFlags;
-                            pDocument->GetScenarioFlags(nScenTab,nFlags);
+                            rDocument.GetScenarioFlags(nScenTab,nFlags);
                             bIsEditable = !((nFlags & ScScenarioFlags::Protected) && (nFlags & ScScenarioFlags::TwoWay));
                         }
                     }
@@ -2536,7 +2536,7 @@ bool ScTable::IsSelectionEditable( const ScMarkData& rMark,
             }
         }
     }
-    else if (pDocument->IsScenario(nTab))
+    else if (rDocument.IsScenario(nTab))
     {
         // Determine if the preceding sheet is protected
         SCTAB nActualTab = nTab;
@@ -2544,19 +2544,19 @@ bool ScTable::IsSelectionEditable( const ScMarkData& rMark,
         {
             nActualTab--;
         }
-        while(pDocument->IsScenario(nActualTab));
+        while(rDocument.IsScenario(nActualTab));
 
-        if(pDocument->IsTabProtected(nActualTab))
+        if(rDocument.IsTabProtected(nActualTab))
         {
             ScRangeList aRanges;
             rMark.FillRangeListWithMarks( &aRanges, false );
             for (size_t i = 0, nRange = aRanges.size(); (i < nRange) && bIsEditable; i++)
             {
                 const ScRange & rRange = aRanges[ i ];
-                if(pDocument->HasScenarioRange(nTab, rRange))
+                if(rDocument.HasScenarioRange(nTab, rRange))
                 {
                     ScScenarioFlags nFlags;
-                    pDocument->GetScenarioFlags(nTab,nFlags);
+                    rDocument.GetScenarioFlags(nTab,nFlags);
                     bIsEditable = !(nFlags & ScScenarioFlags::Protected);
                 }
             }
@@ -2736,7 +2736,7 @@ void ScTable::ApplyStyleArea( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, S
 
     PutInOrder(nStartCol, nEndCol);
     PutInOrder(nStartRow, nEndRow);
-    if ( nEndCol == pDocument->MaxCol() )
+    if ( nEndCol == rDocument.MaxCol() )
     {
         if ( nStartCol < aCol.size() )
         {
@@ -2858,13 +2858,13 @@ void ScTable::StyleSheetChanged( const SfxStyleSheetBase* pStyleSheet, bool bRem
                                 double nPPTX, double nPPTY,
                                 const Fraction& rZoomX, const Fraction& rZoomY )
 {
-    ScFlatBoolRowSegments aUsedRows(pDocument->MaxRow());
+    ScFlatBoolRowSegments aUsedRows(rDocument.MaxRow());
     for (SCCOL i = 0; i < aCol.size(); ++i)
         aCol[i].FindStyleSheet(pStyleSheet, aUsedRows, bRemoved);
 
-    sc::RowHeightContext aCxt(pDocument->MaxRow(), nPPTX, nPPTY, rZoomX, rZoomY, pDev);
+    sc::RowHeightContext aCxt(rDocument.MaxRow(), nPPTX, nPPTY, rZoomX, rZoomY, pDev);
     SCROW nRow = 0;
-    while (nRow <= pDocument->MaxRow())
+    while (nRow <= rDocument.MaxRow())
     {
         ScFlatBoolRowSegments::RangeData aData;
         if (!aUsedRows.getRangeData(nRow, aData))
@@ -3050,7 +3050,7 @@ bool ScTable::SetRowHeightRange( SCROW nStartRow, SCROW nEndRow, sal_uInt16 nNew
         }
 
         bool bSingle = false;   // true = process every row for its own
-        ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer();
+        ScDrawLayer* pDrawLayer = rDocument.GetDrawLayer();
         if (pDrawLayer)
             if (pDrawLayer->HasObjectsInRows( nTab, nStartRow, nEndRow ))
                 bSingle = true;
@@ -3170,7 +3170,7 @@ sal_uInt16 ScTable::GetCommonWidth( SCCOL nEndCol ) const
     if ( !ValidCol(nEndCol) )
     {
         OSL_FAIL("wrong column");
-        nEndCol = pDocument->MaxCol();
+        nEndCol = rDocument.MaxCol();
     }
 
     sal_uInt16 nMaxWidth = 0;
@@ -3379,9 +3379,9 @@ void ScTable::ShowCol(SCCOL nCol, bool bShow)
         {
             SetColHidden(nCol, nCol, !bShow);
 
-            ScChartListenerCollection* pCharts = pDocument->GetChartListenerCollection();
+            ScChartListenerCollection* pCharts = rDocument.GetChartListenerCollection();
             if ( pCharts )
-                pCharts->SetRangeDirty(ScRange( nCol, 0, nTab, nCol, pDocument->MaxRow(), nTab ));
+                pCharts->SetRangeDirty(ScRange( nCol, 0, nTab, nCol, rDocument.MaxRow(), nTab ));
         }
     }
     else
@@ -3400,9 +3400,9 @@ void ScTable::ShowRow(SCROW nRow, bool bShow)
             SetRowHidden(nRow, nRow, !bShow);
             if (bShow)
                 SetRowFiltered(nRow, nRow, false);
-            ScChartListenerCollection* pCharts = pDocument->GetChartListenerCollection();
+            ScChartListenerCollection* pCharts = rDocument.GetChartListenerCollection();
             if ( pCharts )
-                pCharts->SetRangeDirty(ScRange( 0, nRow, nTab, pDocument->MaxCol(), nRow, nTab ));
+                pCharts->SetRangeDirty(ScRange( 0, nRow, nTab, rDocument.MaxCol(), nRow, nTab ));
 
             InvalidatePageBreaks();
         }
@@ -3423,9 +3423,9 @@ void ScTable::DBShowRow(SCROW nRow, bool bShow)
 
         if (bChanged)
         {
-            ScChartListenerCollection* pCharts = pDocument->GetChartListenerCollection();
+            ScChartListenerCollection* pCharts = rDocument.GetChartListenerCollection();
             if ( pCharts )
-                pCharts->SetRangeDirty(ScRange( 0, nRow, nTab, pDocument->MaxCol(), nRow, nTab ));
+                pCharts->SetRangeDirty(ScRange( 0, nRow, nTab, rDocument.MaxCol(), nRow, nTab ));
 
             if (pOutlineTable)
                 UpdateOutlineRow( nRow, nRow, bShow );
@@ -3456,9 +3456,9 @@ void ScTable::DBShowRows(SCROW nRow1, SCROW nRow2, bool bShow)
 
         if ( bChanged )
         {
-            ScChartListenerCollection* pCharts = pDocument->GetChartListenerCollection();
+            ScChartListenerCollection* pCharts = rDocument.GetChartListenerCollection();
             if ( pCharts )
-                pCharts->SetRangeDirty(ScRange( 0, nStartRow, nTab, pDocument->MaxCol(), nEndRow, nTab ));
+                pCharts->SetRangeDirty(ScRange( 0, nStartRow, nTab, rDocument.MaxCol(), nEndRow, nTab ));
         }
 
         nStartRow = nEndRow + 1;
@@ -3476,7 +3476,7 @@ void ScTable::ShowRows(SCROW nRow1, SCROW nRow2, bool bShow)
     SCROW nStartRow = nRow1;
 
     // #i116164# if there are no drawing objects within the row range, a single HeightChanged call is enough
-    ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer();
+    ScDrawLayer* pDrawLayer = rDocument.GetDrawLayer();
     bool bHasObjects = pDrawLayer && pDrawLayer->HasObjectsInRows( nTab, nRow1, nRow2 );
 
     while (nStartRow <= nRow2)
@@ -3494,9 +3494,9 @@ void ScTable::ShowRows(SCROW nRow1, SCROW nRow2, bool bShow)
 
         if ( bChanged )
         {
-            ScChartListenerCollection* pCharts = pDocument->GetChartListenerCollection();
+            ScChartListenerCollection* pCharts = rDocument.GetChartListenerCollection();
             if ( pCharts )
-                pCharts->SetRangeDirty(ScRange( 0, nStartRow, nTab, pDocument->MaxCol(), nEndRow, nTab ));
+                pCharts->SetRangeDirty(ScRange( 0, nStartRow, nTab, rDocument.MaxCol(), nEndRow, nTab ));
 
             InvalidatePageBreaks();
         }
@@ -3657,7 +3657,7 @@ void ScTable::ExtendHidden( SCCOL& rX1, SCROW& rY1, SCCOL& rX2, SCROW& rY2 )
     while (rX1 > 0 && ColHidden(rX1-1))
         --rX1;
 
-    while (rX2 < pDocument->MaxCol() && ColHidden(rX2+1))
+    while (rX2 < rDocument.MaxCol() && ColHidden(rX2+1))
         ++rX2;
 
     // Row-wise expansion
@@ -3672,7 +3672,7 @@ void ScTable::ExtendHidden( SCCOL& rX1, SCROW& rY1, SCCOL& rX2, SCROW& rY2 )
                 rY1 = nStartRow;
         }
     }
-    if (rY2 < pDocument->MaxRow())
+    if (rY2 < rDocument.MaxRow())
     {
         SCROW nEndRow = -1;
         if (RowHidden(rY2+1, nullptr, &nEndRow) && ValidRow(nEndRow))
@@ -3767,7 +3767,7 @@ void ScTable::DoAutoOutline( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SC
 
                             // Rows
 
-    UsedRowsType aUsed(0, pDocument->MaxRow()+1, false);
+    UsedRowsType aUsed(0, rDocument.MaxRow()+1, false);
     for (nCol=nStartCol; nCol<=nEndCol; nCol++)
         aCol[nCol].FindUsed(nStartRow, nEndRow, aUsed);
     aUsed.build_tree();
@@ -3842,11 +3842,11 @@ void ScTable::CopyData( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW n
             aSrc.SetCol( nCol );
             aDest.SetCol( nDestX );
             ScCellValue aCell;
-            aCell.assign(*pDocument, ScAddress(nCol, nRow, nTab));
+            aCell.assign(rDocument, ScAddress(nCol, nRow, nTab));
 
             if (aCell.meType == CELLTYPE_FORMULA)
             {
-                sc::RefUpdateContext aCxt(*pDocument);
+                sc::RefUpdateContext aCxt(rDocument);
                 aCxt.meMode = URM_COPY;
                 aCxt.maRange = aRange;
                 aCxt.mnColDelta = nDestCol - nStartCol;
@@ -3863,8 +3863,8 @@ void ScTable::CopyData( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW n
             }
             else
             {
-                aCell.release(*pDocument, aDest);
-                pDocument->SetPattern( aDest, *GetPattern( nCol, nRow ) );
+                aCell.release(rDocument, aDest);
+                rDocument.SetPattern( aDest, *GetPattern( nCol, nRow ) );
             }
 
             ++nDestX;
@@ -3905,11 +3905,11 @@ void ScTable::GetUpperCellString(SCCOL nCol, SCROW nRow, OUString& rStr)
 
 void ScTable::SetDrawPageSize(bool bResetStreamValid, bool bUpdateNoteCaptionPos)
 {
-    ScDrawLayer* pDrawLayer = pDocument->GetDrawLayer();
+    ScDrawLayer* pDrawLayer = rDocument.GetDrawLayer();
     if( pDrawLayer )
     {
-        double fValX = GetColOffset( pDocument->MaxCol() + 1 ) * HMM_PER_TWIPS;
-        double fValY = GetRowOffset( pDocument->MaxRow() + 1 ) * HMM_PER_TWIPS;
+        double fValX = GetColOffset( rDocument.MaxCol() + 1 ) * HMM_PER_TWIPS;
+        double fValY = GetRowOffset( rDocument.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.
@@ -3976,7 +3976,7 @@ SCROW ScTable::GetRowForHeight(sal_uLong nHeight) const
     aRowHeightRange.mnRow2 = -1;
     aRowHeightRange.mnValue = 0; // silence MSVC C4701
 
-    for (SCROW nRow = 0; nRow <= pDocument->MaxRow(); ++nRow)
+    for (SCROW nRow = 0; nRow <= rDocument.MaxRow(); ++nRow)
     {
         if (!mpHiddenRows->getRangeData(nRow, aData))
             // Failed to fetch the range data for whatever reason.
@@ -4000,8 +4000,8 @@ SCROW ScTable::GetRowForHeight(sal_uLong nHeight) const
 
         if (nSum > nHeight)
         {
-            if (nRow >= pDocument->MaxRow())
-                return pDocument->MaxRow();
+            if (nRow >= rDocument.MaxRow())
+                return rDocument.MaxRow();
 
             // Find the next visible row.
             ++nRow;
@@ -4014,7 +4014,7 @@ SCROW ScTable::GetRowForHeight(sal_uLong nHeight) const
                 // These rows are hidden.
                 nRow = aData.mnRow2 + 1;
 
-            return nRow <= pDocument->MaxRow() ? nRow : pDocument->MaxRow();
+            return nRow <= rDocument.MaxRow() ? nRow : rDocument.MaxRow();
         }
     }
     return -1;
diff --git a/sc/source/core/data/table3.cxx b/sc/source/core/data/table3.cxx
index 7a34da65b1ca..1c8d5db104bc 100644
--- a/sc/source/core/data/table3.cxx
+++ b/sc/source/core/data/table3.cxx
@@ -957,12 +957,12 @@ void ScTable::SortReorderByColumn(
         // Get all area listeners that listen on one column within the range
         // and end their listening.
         ScRange aMoveRange( nStart, nRow1, nTab, nLast, nRow2, nTab);
-        std::vector<sc::AreaListener> aAreaListeners = pDocument->GetBASM()->GetAllListeners(
+        std::vector<sc::AreaListener> aAreaListeners = rDocument.GetBASM()->GetAllListeners(
                 aMoveRange, sc::AreaOverlapType::OneColumnInside);
         {
             for (auto& rAreaListener : aAreaListeners)
             {
-                pDocument->EndListeningArea(rAreaListener.maArea, rAreaListener.mbGroupListening, rAreaListener.mpListener);
+                rDocument.EndListeningArea(rAreaListener.maArea, rAreaListener.mbGroupListening, rAreaListener.mpListener);
                 aListeners.push_back( rAreaListener.mpListener);
             }
         }
@@ -986,7 +986,7 @@ void ScTable::SortReorderByColumn(
                     aNewRange.aStart.SetCol( itCol->second);
                     aNewRange.aEnd.SetCol( itCol->second);
                 }
-                pDocument->StartListeningArea(aNewRange, rAreaListener.mbGroupListening, rAreaListener.mpListener);
+                rDocument.StartListeningArea(aNewRange, rAreaListener.mbGroupListening, rAreaListener.mpListener);
             }
         }
     }
@@ -1005,7 +1005,7 @@ void ScTable::SortReorderByColumn(
         sc::CellStoreType& rCells = aCol[nCol].maCells;
         sc::CellStoreType::position_type aPos = rCells.position(nRow1);
         sc::SharedFormulaUtil::joinFormulaCellAbove(aPos);
-        if (nRow2 < pDocument->MaxRow())
+        if (nRow2 < rDocument.MaxRow())
         {
             aPos = rCells.position(aPos.first, nRow2+1);
             sc::SharedFormulaUtil::joinFormulaCellAbove(aPos);
@@ -1031,7 +1031,7 @@ void ScTable::SortReorderByRow(
     // cells in the sorted range before reordering, and re-start them
     // afterward.
     {
-        sc::EndListeningContext aCxt(*pDocument);
+        sc::EndListeningContext aCxt(rDocument);
         DetachFormulaCells(aCxt, nCol1, nRow1, nCol2, nRow2);
     }
 
@@ -1106,13 +1106,13 @@ void ScTable::SortReorderByRow(
             for (const auto& rSpan : aSpans)
             {
                 assert(rSpan.mpPattern); // should never be NULL.
-                pDocument->GetPool()->Put(*rSpan.mpPattern);
+                rDocument.GetPool()->Put(*rSpan.mpPattern);
             }
 
             for (const auto& rSpan : aSpans)
             {
                 aCol[nThisCol].SetPatternArea(rSpan.mnRow1, rSpan.mnRow2, *rSpan.mpPattern);
-                pDocument->GetPool()->Remove(*rSpan.mpPattern);
+                rDocument.GetPool()->Remove(*rSpan.mpPattern);
             }
         }
 
@@ -1152,7 +1152,7 @@ void ScTable::SortReorderByRow(
         aCol[i].RegroupFormulaCells();
 
     {
-        sc::StartListeningContext aCxt(*pDocument);
+        sc::StartListeningContext aCxt(rDocument);
         AttachFormulaCells(aCxt, nCol1, nRow1, nCol2, nRow2);
     }
 }
@@ -1175,7 +1175,7 @@ void ScTable::SortReorderByRowRefUpdate(
         // Get the range of formula group listeners within sorted range (if any).
         sc::QueryRange aQuery;
 
-        ScBroadcastAreaSlotMachine* pBASM = pDocument->GetBASM();
+        ScBroadcastAreaSlotMachine* pBASM = rDocument.GetBASM();
         std::vector<sc::AreaListener> aGrpListeners =
             pBASM->GetAllListeners(
                 aMoveRange, sc::AreaOverlapType::InsideOrOverlap, sc::ListenerGroupType::Group);
@@ -1186,7 +1186,7 @@ void ScTable::SortReorderByRowRefUpdate(
                 assert(rGrpListener.mbGroupListening);
                 SvtListener* pGrpLis = rGrpListener.mpListener;
                 pGrpLis->Query(aQuery);
-                pDocument->EndListeningArea(rGrpListener.maArea, rGrpListener.mbGroupListening, pGrpLis);
+                rDocument.EndListeningArea(rGrpListener.maArea, rGrpListener.mbGroupListening, pGrpLis);
             }
         }
 
@@ -1303,13 +1303,13 @@ void ScTable::SortReorderByRowRefUpdate(
             for (const auto& rSpan : aSpans)
             {
                 assert(rSpan.mpPattern); // should never be NULL.
-                pDocument->GetPool()->Put(*rSpan.mpPattern);
+                rDocument.GetPool()->Put(*rSpan.mpPattern);
             }
 
             for (const auto& rSpan : aSpans)
             {
                 aCol[nThisCol].SetPatternArea(rSpan.mnRow1, rSpan.mnRow2, *rSpan.mpPattern);
-                pDocument->GetPool()->Remove(*rSpan.mpPattern);
+                rDocument.GetPool()->Remove(*rSpan.mpPattern);
             }
         }
 
@@ -1356,12 +1356,12 @@ void ScTable::SortReorderByRowRefUpdate(
 
     // Get all area listeners that listen on one row within the range and end
     // their listening.
-    std::vector<sc::AreaListener> aAreaListeners = pDocument->GetBASM()->GetAllListeners(
+    std::vector<sc::AreaListener> aAreaListeners = rDocument.GetBASM()->GetAllListeners(
             aMoveRange, sc::AreaOverlapType::OneRowInside);
     {
         for (auto& rAreaListener : aAreaListeners)
         {
-            pDocument->EndListeningArea(rAreaListener.maArea, rAreaListener.mbGroupListening, rAreaListener.mpListener);
+            rDocument.EndListeningArea(rAreaListener.maArea, rAreaListener.mbGroupListening, rAreaListener.mpListener);
             aListeners.push_back( rAreaListener.mpListener);
         }
     }
@@ -1371,7 +1371,7 @@ void ScTable::SortReorderByRowRefUpdate(
 
         std::vector<ScFormulaCell*> aFCells;
         FormulaCellCollectAction aAction(aFCells);
-        aGrpListenerRanges.executeColumnAction(*pDocument, aAction);
+        aGrpListenerRanges.executeColumnAction(rDocument, aAction);
 
         aListeners.insert( aListeners.end(), aFCells.begin(), aFCells.end() );
     }
@@ -1393,7 +1393,7 @@ void ScTable::SortReorderByRowRefUpdate(
         for (const auto& [nCol, rCol] : rCols)
         {
             std::vector<SCROW> aBounds(rCol);
-            pDocument->UnshareFormulaCells(rTab, nCol, aBounds);
+            rDocument.UnshareFormulaCells(rTab, nCol, aBounds);
         }
     }
 
@@ -1405,7 +1405,7 @@ void ScTable::SortReorderByRowRefUpdate(
     for (const auto& [rTab, rCols] : rGroupTabs)
     {
         for (const auto& rEntry : rCols)
-            pDocument->RegroupFormulaCells(rTab, rEntry.first);
+            rDocument.RegroupFormulaCells(rTab, rEntry.first);
     }
 
     // Re-start area listeners on the reordered rows.
@@ -1418,7 +1418,7 @@ void ScTable::SortReorderByRowRefUpdate(
             aNewRange.aStart.SetRow( itRow->second);
             aNewRange.aEnd.SetRow( itRow->second);
         }
-        pDocument->StartListeningArea(aNewRange, rAreaListener.mbGroupListening, rAreaListener.mpListener);
+        rDocument.StartListeningArea(aNewRange, rAreaListener.mbGroupListening, rAreaListener.mpListener);
     }
 
     // Re-group columns in the sorted range too.
@@ -1427,8 +1427,8 @@ void ScTable::SortReorderByRowRefUpdate(
 
     {
         // Re-start area listeners on the old group listener ranges.
-        ListenerStartAction aAction(*pDocument);
-        aGrpListenerRanges.executeColumnAction(*pDocument, aAction);
+        ListenerStartAction aAction(rDocument);
+        aGrpListenerRanges.executeColumnAction(rDocument, aAction);
     }
 }
 
@@ -1876,7 +1876,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, pDocument->MaxCol(), nTab, nRow, 1);
+            rDocument.DeleteRow(0, nTab, rDocument.MaxCol(), nTab, nRow, 1);
         });
 
     rParam.nRow2 -= aRows.size();
@@ -1946,7 +1946,7 @@ bool ScTable::DoSubTotals( ScSubTotalParam& rParam )
     sal_uInt16 i;
 
     //  Remove empty rows at the end
-    //  so that all exceeding (pDocument->MaxRow()) can be found by InsertRow (#35180#)
+    //  so that all exceeding (rDocument.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;
@@ -1977,7 +1977,7 @@ bool ScTable::DoSubTotals( ScSubTotalParam& rParam )
 
                                 //TODO: sort?
 
-    ScStyleSheet* pStyle = static_cast<ScStyleSheet*>(pDocument->GetStyleSheetPool()->Find(
+    ScStyleSheet* pStyle = static_cast<ScStyleSheet*>(rDocument.GetStyleSheetPool()->Find(
                                 ScResId(STR_STYLENAME_RESULT), SfxStyleFamily::Para ));
 
     bool bSpaceLeft = true;                                         // Success when inserting?
@@ -2042,10 +2042,10 @@ bool ScTable::DoSubTotals( ScSubTotalParam& rParam )
                     aRowEntry.nFuncStart = aRowEntry.nSubStartRow;
                     aRowEntry.nFuncEnd   = nRow-1;
 
-                    bSpaceLeft = pDocument->InsertRow( 0, nTab, pDocument->MaxCol(), nTab,
+                    bSpaceLeft = rDocument.InsertRow( 0, nTab, rDocument.MaxCol(), nTab,
                             aRowEntry.nDestRow, 1 );
                     DBShowRow( aRowEntry.nDestRow, bBlockVis );
-                    if ( rParam.bPagebreak && nRow < pDocument->MaxRow() &&
+                    if ( rParam.bPagebreak && nRow < rDocument.MaxRow() &&
                             aRowEntry.nSubStartRow != nStartRow && nLevel == 0)
                         SetRowBreak(aRowEntry.nSubStartRow, false, true);
 
@@ -2131,7 +2131,7 @@ bool ScTable::DoSubTotals( ScSubTotalParam& rParam )
             // increment row
             nGlobalEndFunc++;
 
-            bSpaceLeft = pDocument->InsertRow(0, nTab, pDocument->MaxCol(), nTab, aRowEntry.nDestRow, 1);
+            bSpaceLeft = rDocument.InsertRow(0, nTab, rDocument.MaxCol(), nTab, aRowEntry.nDestRow, 1);
 
             if (bSpaceLeft)
             {
@@ -2164,7 +2164,7 @@ bool ScTable::DoSubTotals( ScSubTotalParam& rParam )
             aRef.Ref2.SetAbsCol(nResCols[nResult]);
             aRef.Ref2.SetAbsRow(rRowEntry.nFuncEnd);
 
-            ScTokenArray aArr(*pDocument);
+            ScTokenArray aArr(rDocument);
             aArr.AddOpCode( ocSubTotal );
             aArr.AddOpCode( ocOpen );
             aArr.AddDouble( static_cast<double>(pResFunc[nResult]) );
@@ -2173,7 +2173,7 @@ bool ScTable::DoSubTotals( ScSubTotalParam& rParam )
             aArr.AddOpCode( ocClose );
             aArr.AddOpCode( ocStop );
             ScFormulaCell* pCell = new ScFormulaCell(
-                pDocument, ScAddress(nResCols[nResult], rRowEntry.nDestRow, nTab), aArr);
+                &rDocument, ScAddress(nResCols[nResult], rRowEntry.nDestRow, nTab), aArr);
             if ( rParam.bIncludePattern )
                 pCell->SetNeedNumberFormat(true);
 
@@ -2749,7 +2749,7 @@ bool ScTable::ValidQuery(
     bool* pTest = ( nEntryCount <= nFixedBools ? &aTest[0] : new bool[nEntryCount] );
 
     long    nPos = -1;
-    QueryEvaluator aEval(*pDocument, *this, rParam, pbTestEqualCondition != nullptr);
+    QueryEvaluator aEval(rDocument, *this, rParam, pbTestEqualCondition != nullptr);
     ScQueryParam::const_iterator it, itBeg = rParam.begin(), itEnd = rParam.end();
     for (it = itBeg; it != itEnd && (*it)->bDoQuery; ++it)
     {
@@ -3068,7 +3068,7 @@ SCSIZE ScTable::Query(const ScQueryParam& rParamOrg, bool bKeepSub)
     SCROW nOutRow   = 0;
     SCROW nHeader   = aParam.bHasHeader ? 1 : 0;
 
-    lcl_PrepareQuery(pDocument, this, aParam);
+    lcl_PrepareQuery(&rDocument, this, aParam);
 
     if (!aParam.bInplace)
     {
@@ -3178,7 +3178,7 @@ bool ScTable::CreateExcelQuery(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow
             if ( nTab == nDBTab )
                 GetUpperCellString(i, nDBRow1, aCellStr);
             else
-                pDocument->GetUpperCellString(i, nDBRow1, nDBTab, aCellStr);
+                rDocument.GetUpperCellString(i, nDBRow1, nDBTab, aCellStr);
             bFound = (aCellStr == aQueryStr);
             if (!bFound) i++;
         }
@@ -3205,7 +3205,7 @@ bool ScTable::CreateExcelQuery(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow
 
         SCSIZE nIndex = 0;
         SCROW nRow = nRow1 + 1;
-        svl::SharedStringPool& rPool = pDocument->GetSharedStringPool();
+        svl::SharedStringPool& rPool = rDocument.GetSharedStringPool();
         while (nRow <= nRow2)
         {
             nCol = nCol1;
@@ -3259,7 +3259,7 @@ bool ScTable::CreateStarQuery(SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2
 
     SCSIZE nNewEntries = static_cast<SCSIZE>(nRow2-nRow1+1);
     rQueryParam.Resize( nNewEntries );
-    svl::SharedStringPool& rPool = pDocument->GetSharedStringPool();
+    svl::SharedStringPool& rPool = rDocument.GetSharedStringPool();
 
     do
     {

... etc. - the rest is truncated


More information about the Libreoffice-commits mailing list