Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2960 insertions, 0 deletions

diff --git a/sw/source/core/table/swtable.cxx b/sw/source/core/table/swtable.cxx
new file mode 100644
index 000000000..c2ff14822
--- /dev/null
+++ b/sw/source/core/table/swtable.cxx
@@ -0,0 +1,2960 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <hintids.hxx>
+#include <hints.hxx>
+#include <editeng/lrspitem.hxx>
+#include <editeng/shaditem.hxx>
+#include <editeng/adjustitem.hxx>
+#include <editeng/colritem.hxx>
+#include <osl/diagnose.h>
+#include <sfx2/linkmgr.hxx>
+#include <fmtfsize.hxx>
+#include <fmtornt.hxx>
+#include <fmtpdsc.hxx>
+#include <fldbas.hxx>
+#include <fmtfld.hxx>
+#include <frmatr.hxx>
+#include <doc.hxx>
+#include <IDocumentLinksAdministration.hxx>
+#include <IDocumentRedlineAccess.hxx>
+#include <IDocumentFieldsAccess.hxx>
+#include <docary.hxx>
+#include <frame.hxx>
+#include <swtable.hxx>
+#include <ndtxt.hxx>
+#include <tabcol.hxx>
+#include <tabfrm.hxx>
+#include <cellfrm.hxx>
+#include <rowfrm.hxx>
+#include <swserv.hxx>
+#include <expfld.hxx>
+#include <mdiexp.hxx>
+#include <cellatr.hxx>
+#include <txatbase.hxx>
+#include <htmltbl.hxx>
+#include <swtblfmt.hxx>
+#include <ndindex.hxx>
+#include <tblrwcl.hxx>
+#include <shellres.hxx>
+#include <viewsh.hxx>
+#include <redline.hxx>
+#include <vector>
+#include <calbck.hxx>
+#include <o3tl/string_view.hxx>
+#include <svl/numformat.hxx>
+
+#ifdef DBG_UTIL
+#define CHECK_TABLE(t) (t).CheckConsistency();
+#else
+#define CHECK_TABLE(t)
+#endif
+
+using namespace com::sun::star;
+
+
+#define COLFUZZY 20
+
+static void ChgTextToNum( SwTableBox& rBox, const OUString& rText, const Color* pCol,
+                    bool bChgAlign, SwNodeOffset nNdPos );
+
+sal_Int32 SwTableBox::getRowSpan() const
+{
+    return mnRowSpan;
+}
+
+void SwTableBox::setRowSpan( sal_Int32 nNewRowSpan )
+{
+    mnRowSpan = nNewRowSpan;
+}
+
+bool SwTableBox::getDummyFlag() const
+{
+    return mbDummyFlag;
+}
+
+void SwTableBox::setDummyFlag( bool bDummy )
+{
+    mbDummyFlag = bDummy;
+}
+
+//JP 15.09.98: Bug 55741 - Keep tabs (front and rear)
+static OUString& lcl_TabToBlankAtSttEnd( OUString& rText )
+{
+    sal_Unicode c;
+    sal_Int32 n;
+
+    for( n = 0; n < rText.getLength() && ' ' >= ( c = rText[n] ); ++n )
+        if( '\x9' == c )
+            rText = rText.replaceAt( n, 1, u" " );
+    for( n = rText.getLength(); n && ' ' >= ( c = rText[--n] ); )
+        if( '\x9' == c )
+            rText = rText.replaceAt( n, 1, u" " );
+    return rText;
+}
+
+static OUString& lcl_DelTabsAtSttEnd( OUString& rText )
+{
+    sal_Unicode c;
+    sal_Int32 n;
+    OUStringBuffer sBuff(rText);
+
+    for( n = 0; n < sBuff.getLength() && ' ' >= ( c = sBuff[ n ]); ++n )
+    {
+        if( '\x9' == c )
+            sBuff.remove( n--, 1 );
+    }
+    for( n = sBuff.getLength(); n && ' ' >= ( c = sBuff[ --n ]); )
+    {
+        if( '\x9' == c )
+            sBuff.remove( n, 1 );
+    }
+    rText = sBuff.makeStringAndClear();
+    return rText;
+}
+
+void InsTableBox( SwDoc& rDoc, SwTableNode* pTableNd,
+                        SwTableLine* pLine, SwTableBoxFormat* pBoxFrameFormat,
+                        SwTableBox* pBox,
+                        sal_uInt16 nInsPos, sal_uInt16 nCnt )
+{
+    OSL_ENSURE( pBox->GetSttNd(), "Box with no start node" );
+    SwNodeIndex aIdx( *pBox->GetSttNd(), +1 );
+    SwContentNode* pCNd = aIdx.GetNode().GetContentNode();
+    if( !pCNd )
+        pCNd = rDoc.GetNodes().GoNext( &aIdx );
+    OSL_ENSURE( pCNd, "Box with no content node" );
+
+    if( pCNd->IsTextNode() )
+    {
+        if( pCNd->GetpSwAttrSet() )
+        {
+            SwAttrSet aAttrSet( *pCNd->GetpSwAttrSet() );
+            if(pCNd->GetSwAttrSet().HasItem(RES_PARATR_LIST_AUTOFMT))
+            {
+                SwFormatAutoFormat format = aAttrSet.Get(RES_PARATR_LIST_AUTOFMT);
+                const std::shared_ptr<SfxItemSet>& handle = format.GetStyleHandle();
+                aAttrSet.Put(*handle);
+            }
+            if( pBox->GetSaveNumFormatColor() )
+            {
+                if( pBox->GetSaveUserColor() )
+                    aAttrSet.Put( SvxColorItem( *pBox->GetSaveUserColor(), RES_CHRATR_COLOR ));
+                else
+                    aAttrSet.ClearItem( RES_CHRATR_COLOR );
+            }
+            rDoc.GetNodes().InsBoxen( pTableNd, pLine, pBoxFrameFormat,
+                                    static_cast<SwTextNode*>(pCNd)->GetTextColl(),
+                                    &aAttrSet, nInsPos, nCnt );
+        }
+        else
+            rDoc.GetNodes().InsBoxen( pTableNd, pLine, pBoxFrameFormat,
+                                    static_cast<SwTextNode*>(pCNd)->GetTextColl(),
+                                    pCNd->GetpSwAttrSet(), nInsPos, nCnt );
+    }
+    else
+        rDoc.GetNodes().InsBoxen( pTableNd, pLine, pBoxFrameFormat,
+                rDoc.GetDfltTextFormatColl(), nullptr,
+                nInsPos, nCnt );
+
+    sal_Int32 nRowSpan = pBox->getRowSpan();
+    if( nRowSpan != 1 )
+    {
+        SwTableBoxes& rTableBoxes = pLine->GetTabBoxes();
+        for( sal_uInt16 i = 0; i < nCnt; ++i )
+        {
+            pBox = rTableBoxes[ i + nInsPos ];
+            pBox->setRowSpan( nRowSpan );
+        }
+    }
+}
+
+SwTable::SwTable()
+    : SwClient( nullptr ),
+    m_pTableNode( nullptr ),
+    m_nGraphicsThatResize( 0 ),
+    m_nRowsToRepeat( 1 ),
+    m_bModifyLocked( false ),
+    m_bNewModel( true )
+{
+    // default value set in the options
+    m_eTableChgMode = GetTableChgDefaultMode();
+}
+
+SwTable::SwTable( const SwTable& rTable )
+    : SwClient( rTable.GetFrameFormat() ),
+    m_pTableNode( nullptr ),
+    m_eTableChgMode( rTable.m_eTableChgMode ),
+    m_nGraphicsThatResize( 0 ),
+    m_nRowsToRepeat( rTable.GetRowsToRepeat() ),
+    maTableStyleName(rTable.maTableStyleName),
+    m_bModifyLocked( false ),
+    m_bNewModel( rTable.m_bNewModel )
+{
+}
+
+void DelBoxNode( SwTableSortBoxes const & rSortCntBoxes )
+{
+    for (size_t n = 0; n < rSortCntBoxes.size(); ++n)
+    {
+        rSortCntBoxes[ n ]->m_pStartNode = nullptr;
+    }
+}
+
+SwTable::~SwTable()
+{
+    if( m_xRefObj.is() )
+    {
+        SwDoc* pDoc = GetFrameFormat()->GetDoc();
+        if( !pDoc->IsInDtor() )         // then remove from the list
+            pDoc->getIDocumentLinksAdministration().GetLinkManager().RemoveServer( m_xRefObj.get() );
+
+        m_xRefObj->Closed();
+    }
+
+    // the table can be deleted if it's the last client of the FrameFormat
+    SwTableFormat* pFormat = GetFrameFormat();
+    pFormat->Remove( this );               // remove
+
+    if( !pFormat->HasWriterListeners() )
+        pFormat->GetDoc()->DelTableFrameFormat( pFormat );   // and delete
+
+    // Delete the pointers from the SortArray of the boxes. The objects
+    // are preserved and are deleted by the lines/boxes arrays dtor.
+    // Note: unfortunately not enough, pointers to the StartNode of the
+    // section need deletion.
+    DelBoxNode(m_TabSortContentBoxes);
+    m_TabSortContentBoxes.clear();
+}
+
+namespace
+{
+
+template<class T>
+T lcl_MulDiv64(sal_uInt64 nA, sal_uInt64 nM, sal_uInt64 nD)
+{
+    assert(nD != 0);
+    return nD == 0 ? static_cast<T>(nA*nM) : static_cast<T>((nA*nM)/nD);
+}
+
+}
+
+static void FormatInArr( std::vector<SwFormat*>& rFormatArr, SwFormat* pBoxFormat )
+{
+    std::vector<SwFormat*>::const_iterator it = std::find( rFormatArr.begin(), rFormatArr.end(), pBoxFormat );
+    if ( it == rFormatArr.end() )
+        rFormatArr.push_back( pBoxFormat );
+}
+
+static void lcl_ModifyBoxes( SwTableBoxes &rBoxes, const tools::Long nOld,
+                         const tools::Long nNew, std::vector<SwFormat*>& rFormatArr );
+
+static void lcl_ModifyLines( SwTableLines &rLines, const tools::Long nOld,
+                         const tools::Long nNew, std::vector<SwFormat*>& rFormatArr, const bool bCheckSum )
+{
+    for ( size_t i = 0; i < rLines.size(); ++i )
+        ::lcl_ModifyBoxes( rLines[i]->GetTabBoxes(), nOld, nNew, rFormatArr );
+    if( bCheckSum )
+    {
+        for(SwFormat* pFormat : rFormatArr)
+        {
+            const SwTwips nBox = lcl_MulDiv64<SwTwips>(pFormat->GetFrameSize().GetWidth(), nNew, nOld);
+            SwFormatFrameSize aNewBox( SwFrameSize::Variable, nBox, 0 );
+            pFormat->LockModify();
+            pFormat->SetFormatAttr( aNewBox );
+            pFormat->UnlockModify();
+        }
+    }
+}
+
+static void lcl_ModifyBoxes( SwTableBoxes &rBoxes, const tools::Long nOld,
+                         const tools::Long nNew, std::vector<SwFormat*>& rFormatArr )
+{
+    sal_uInt64 nSum = 0; // To avoid rounding errors we summarize all box widths
+    sal_uInt64 nOriginalSum = 0; // Sum of original widths
+    for ( size_t i = 0; i < rBoxes.size(); ++i )
+    {
+        SwTableBox &rBox = *rBoxes[i];
+        if ( !rBox.GetTabLines().empty() )
+        {
+            // For SubTables the rounding problem will not be solved :-(
+            ::lcl_ModifyLines( rBox.GetTabLines(), nOld, nNew, rFormatArr, false );
+        }
+        // Adjust the box
+        SwFrameFormat *pFormat = rBox.GetFrameFormat();
+        sal_uInt64 nBox = pFormat->GetFrameSize().GetWidth();
+        nOriginalSum += nBox;
+        nBox = lcl_MulDiv64<sal_uInt64>(nBox, nNew, nOld);
+        const sal_uInt64 nWishedSum = lcl_MulDiv64<sal_uInt64>(nOriginalSum, nNew, nOld) - nSum;
+        if( nWishedSum > 0 )
+        {
+            if( nBox == nWishedSum )
+                FormatInArr( rFormatArr, pFormat );
+            else
+            {
+                nBox = nWishedSum;
+                pFormat = rBox.ClaimFrameFormat();
+                SwFormatFrameSize aNewBox( SwFrameSize::Variable, static_cast< SwTwips >(nBox), 0 );
+                pFormat->LockModify();
+                pFormat->SetFormatAttr( aNewBox );
+                pFormat->UnlockModify();
+            }
+        }
+        else {
+            OSL_FAIL( "Rounding error" );
+        }
+        nSum += nBox;
+    }
+}
+
+void SwTable::SwClientNotify(const SwModify&, const SfxHint& rHint)
+{
+    if (rHint.GetId() != SfxHintId::SwLegacyModify)
+        return;
+    auto pLegacy = static_cast<const sw::LegacyModifyHint*>(&rHint);
+    // catch SSize changes, to adjust the lines/boxes
+    const sal_uInt16 nWhich = pLegacy->GetWhich();
+    const SwFormatFrameSize* pNewSize = nullptr, *pOldSize = nullptr;
+    switch(nWhich)
+    {
+        case RES_ATTRSET_CHG:
+        {
+            if (pLegacy->m_pOld && pLegacy->m_pNew
+                    && (pNewSize = static_cast<const SwAttrSetChg*>(pLegacy->m_pNew)->GetChgSet()->GetItemIfSet(
+                            RES_FRM_SIZE,
+                            false)))
+            {
+                pOldSize = &static_cast<const SwAttrSetChg*>(pLegacy->m_pOld)->GetChgSet()->GetFrameSize();
+            }
+        }
+        break;
+        case RES_FRM_SIZE:
+        {
+            pOldSize = static_cast<const SwFormatFrameSize*>(pLegacy->m_pOld);
+            pNewSize = static_cast<const SwFormatFrameSize*>(pLegacy->m_pNew);
+        }
+        break;
+        default:
+            CheckRegistration(pLegacy->m_pOld);
+    }
+    if (pOldSize && pNewSize && !m_bModifyLocked)
+        AdjustWidths(pOldSize->GetWidth(), pNewSize->GetWidth());
+}
+
+void SwTable::AdjustWidths( const tools::Long nOld, const tools::Long nNew )
+{
+    std::vector<SwFormat*> aFormatArr;
+    aFormatArr.reserve( m_aLines[0]->GetTabBoxes().size() );
+    ::lcl_ModifyLines( m_aLines, nOld, nNew, aFormatArr, true );
+}
+
+static void lcl_RefreshHidden( SwTabCols &rToFill, size_t nPos )
+{
+    for ( size_t i = 0; i < rToFill.Count(); ++i )
+    {
+        if ( std::abs(static_cast<tools::Long>(nPos) - rToFill[i]) <= COLFUZZY )
+        {
+            rToFill.SetHidden( i, false );
+            break;
+        }
+    }
+}
+
+static void lcl_SortedTabColInsert( SwTabCols &rToFill, const SwTableBox *pBox,
+                   const SwFrameFormat *pTabFormat, const bool bHidden,
+                   const bool bRefreshHidden )
+{
+    const tools::Long nWish = pTabFormat->GetFrameSize().GetWidth();
+    OSL_ENSURE(nWish, "weird <= 0 width frmfrm");
+
+    // The value for the left edge of the box is calculated from the
+    // widths of the previous boxes.
+    tools::Long nPos = 0;
+    tools::Long nLeftMin = 0;
+    tools::Long nRightMax = 0;
+    if (nWish != 0) //fdo#33012 0 width frmfmt
+    {
+        SwTwips nSum = 0;
+        const SwTableBox  *pCur  = pBox;
+        const SwTableLine *pLine = pBox->GetUpper();
+        const tools::Long nAct  = rToFill.GetRight() - rToFill.GetLeft();  // +1 why?
+
+        while ( pLine )
+        {
+            const SwTableBoxes &rBoxes = pLine->GetTabBoxes();
+            for ( size_t i = 0; i < rBoxes.size(); ++i )
+            {
+                const SwTwips nWidth = rBoxes[i]->GetFrameFormat()->GetFrameSize().GetWidth();
+                nSum += nWidth;
+                const tools::Long nTmp = lcl_MulDiv64<tools::Long>(nSum, nAct, nWish);
+
+                if (rBoxes[i] != pCur)
+                {
+                    if ( pLine == pBox->GetUpper() || 0 == nLeftMin )
+                        nLeftMin = nTmp - nPos;
+                    nPos = nTmp;
+                }
+                else
+                {
+                    nSum -= nWidth;
+                    if ( 0 == nRightMax )
+                        nRightMax = nTmp - nPos;
+                    break;
+                }
+            }
+            pCur  = pLine->GetUpper();
+            pLine = pCur ? pCur->GetUpper() : nullptr;
+        }
+    }
+
+    bool bInsert = !bRefreshHidden;
+    for ( size_t j = 0; bInsert && (j < rToFill.Count()); ++j )
+    {
+        tools::Long nCmp = rToFill[j];
+        if ( (nPos >= ((nCmp >= COLFUZZY) ? nCmp - COLFUZZY : nCmp)) &&
+             (nPos <= (nCmp + COLFUZZY)) )
+        {
+            bInsert = false;        // Already has it.
+        }
+        else if ( nPos < nCmp )
+        {
+            bInsert = false;
+            rToFill.Insert( nPos, bHidden, j );
+        }
+    }
+    if ( bInsert )
+        rToFill.Insert( nPos, bHidden, rToFill.Count() );
+    else if ( bRefreshHidden )
+        ::lcl_RefreshHidden( rToFill, nPos );
+
+    if ( !bHidden || bRefreshHidden )
+        return;
+
+    // calculate minimum/maximum values for the existing entries:
+    nLeftMin = nPos - nLeftMin;
+    nRightMax = nPos + nRightMax;
+
+    // check if nPos is entry:
+    bool bFoundPos = false;
+    bool bFoundMax = false;
+    for ( size_t j = 0; !(bFoundPos && bFoundMax ) && j < rToFill.Count(); ++j )
+    {
+        SwTabColsEntry& rEntry = rToFill.GetEntry( j );
+        tools::Long nCmp = rToFill[j];
+
+        if ( (nPos >= ((nCmp >= COLFUZZY) ? nCmp - COLFUZZY : nCmp)) &&
+             (nPos <= (nCmp + COLFUZZY)) )
+        {
+            // check if nLeftMin is > old minimum for entry nPos:
+            const tools::Long nOldMin = rEntry.nMin;
+            if ( nLeftMin > nOldMin )
+                rEntry.nMin = nLeftMin;
+            // check if nRightMin is < old maximum for entry nPos:
+            const tools::Long nOldMax = rEntry.nMax;
+            if ( nRightMax < nOldMax )
+                rEntry.nMax = nRightMax;
+
+            bFoundPos = true;
+        }
+        else if ( (nRightMax >= ((nCmp >= COLFUZZY) ? nCmp - COLFUZZY : nCmp)) &&
+                  (nRightMax <= (nCmp + COLFUZZY)) )
+        {
+            // check if nPos is > old minimum for entry nRightMax:
+            const tools::Long nOldMin = rEntry.nMin;
+            if ( nPos > nOldMin )
+                rEntry.nMin = nPos;
+
+            bFoundMax = true;
+        }
+    }
+}
+
+static void lcl_ProcessBoxGet( const SwTableBox *pBox, SwTabCols &rToFill,
+                        const SwFrameFormat *pTabFormat, bool bRefreshHidden )
+{
+    if ( !pBox->GetTabLines().empty() )
+    {
+        const SwTableLines &rLines = pBox->GetTabLines();
+        for ( size_t i = 0; i < rLines.size(); ++i )
+        {
+            const SwTableBoxes &rBoxes = rLines[i]->GetTabBoxes();
+            for ( size_t j = 0; j < rBoxes.size(); ++j )
+                ::lcl_ProcessBoxGet( rBoxes[j], rToFill, pTabFormat, bRefreshHidden);
+        }
+    }
+    else
+        ::lcl_SortedTabColInsert( rToFill, pBox, pTabFormat, false, bRefreshHidden );
+}
+
+static void lcl_ProcessLineGet( const SwTableLine *pLine, SwTabCols &rToFill,
+                         const SwFrameFormat *pTabFormat )
+{
+    for ( size_t i = 0; i < pLine->GetTabBoxes().size(); ++i )
+    {
+        const SwTableBox *pBox = pLine->GetTabBoxes()[i];
+        if ( pBox->GetSttNd() )
+            ::lcl_SortedTabColInsert( rToFill, pBox, pTabFormat, true, false );
+        else
+            for ( size_t j = 0; j < pBox->GetTabLines().size(); ++j )
+                ::lcl_ProcessLineGet( pBox->GetTabLines()[j], rToFill, pTabFormat );
+    }
+}
+
+void SwTable::GetTabCols( SwTabCols &rToFill, const SwTableBox *pStart,
+              bool bRefreshHidden, bool bCurRowOnly ) const
+{
+    // Optimization: if bHidden is set, we only update the Hidden Array.
+    if ( bRefreshHidden )
+    {
+        // remove corrections
+        for ( size_t i = 0; i < rToFill.Count(); ++i )
+        {
+            SwTabColsEntry& rEntry = rToFill.GetEntry( i );
+            rEntry.nPos -= rToFill.GetLeft();
+            rEntry.nMin -= rToFill.GetLeft();
+            rEntry.nMax -= rToFill.GetLeft();
+        }
+
+        // All are hidden, so add the visible ones.
+        for ( size_t i = 0; i < rToFill.Count(); ++i )
+            rToFill.SetHidden( i, true );
+    }
+    else
+    {
+        rToFill.Remove( 0, rToFill.Count() );
+    }
+
+    // Insertion cases:
+    // 1. All boxes which are inferior to Line which is superior to the Start,
+    //    as well as their inferior boxes if present.
+    // 2. Starting from the Line, the superior box plus its neighbours; but no inferiors.
+    // 3. Apply 2. to the Line superior to the chain of boxes,
+    //    until the Line's superior is not a box but the table.
+    // Only those boxes are inserted that don't contain further rows. The insertion
+    // function takes care to avoid duplicates. In order to achieve this, we work
+    // with some degree of fuzzyness (to avoid rounding errors).
+    // Only the left edge of the boxes are inserted.
+    // Finally, the first entry is removed again, because it's already
+    // covered by the border.
+    // 4. Scan the table again and insert _all_ boxes, this time as hidden.
+
+    const SwFrameFormat *pTabFormat = GetFrameFormat();
+
+    // 1.
+    const SwTableBoxes &rBoxes = pStart->GetUpper()->GetTabBoxes();
+
+    for ( size_t i = 0; i < rBoxes.size(); ++i )
+        ::lcl_ProcessBoxGet( rBoxes[i], rToFill, pTabFormat, bRefreshHidden );
+
+    // 2. and 3.
+    const SwTableLine *pLine = pStart->GetUpper()->GetUpper() ?
+                                pStart->GetUpper()->GetUpper()->GetUpper() : nullptr;
+    while ( pLine )
+    {
+        const SwTableBoxes &rBoxes2 = pLine->GetTabBoxes();
+        for ( size_t k = 0; k < rBoxes2.size(); ++k )
+            ::lcl_SortedTabColInsert( rToFill, rBoxes2[k],
+                                      pTabFormat, false, bRefreshHidden );
+        pLine = pLine->GetUpper() ? pLine->GetUpper()->GetUpper() : nullptr;
+    }
+
+    if ( !bRefreshHidden )
+    {
+        // 4.
+        if ( !bCurRowOnly )
+        {
+            for ( size_t i = 0; i < m_aLines.size(); ++i )
+                ::lcl_ProcessLineGet( m_aLines[i], rToFill, pTabFormat );
+        }
+
+        rToFill.Remove( 0 );
+    }
+
+    // Now the coordinates are relative to the left table border - i.e.
+    // relative to SwTabCols.nLeft. However, they are expected
+    // relative to the left document border, i.e. SwTabCols.nLeftMin.
+    // So all values need to be extended by nLeft.
+    for ( size_t i = 0; i < rToFill.Count(); ++i )
+    {
+        SwTabColsEntry& rEntry = rToFill.GetEntry( i );
+        rEntry.nPos += rToFill.GetLeft();
+        rEntry.nMin += rToFill.GetLeft();
+        rEntry.nMax += rToFill.GetLeft();
+    }
+}
+
+// Structure for parameter passing
+struct Parm
+{
+    const SwTabCols &rNew;
+    const SwTabCols &rOld;
+    tools::Long nNewWish,
+         nOldWish;
+    std::deque<SwTableBox*> aBoxArr;
+    SwShareBoxFormats aShareFormats;
+
+    Parm( const SwTabCols &rN, const SwTabCols &rO )
+        : rNew( rN ), rOld( rO ), nNewWish(0), nOldWish(0)
+    {}
+};
+
+static void lcl_ProcessBoxSet( SwTableBox *pBox, Parm &rParm );
+
+static void lcl_ProcessLine( SwTableLine *pLine, Parm &rParm )
+{
+    SwTableBoxes &rBoxes = pLine->GetTabBoxes();
+    for ( size_t i = rBoxes.size(); i > 0; )
+    {
+        --i;
+        ::lcl_ProcessBoxSet( rBoxes[i], rParm );
+    }
+}
+
+static void lcl_ProcessBoxSet( SwTableBox *pBox, Parm &rParm )
+{
+    if ( !pBox->GetTabLines().empty() )
+    {
+        SwTableLines &rLines = pBox->GetTabLines();
+        for ( size_t i = rLines.size(); i > 0; )
+        {
+            --i;
+            lcl_ProcessLine( rLines[i], rParm );
+        }
+    }
+    else
+    {
+        // Search the old TabCols for the current position (calculate from
+        // left and right edge). Adjust the box if the values differ from
+        // the new TabCols. If the adjusted edge has no neighbour we also
+        // adjust all superior boxes.
+
+        const tools::Long nOldAct = rParm.rOld.GetRight() -
+                             rParm.rOld.GetLeft(); // +1 why?
+
+        // The value for the left edge of the box is calculated from the
+        // widths of the previous boxes plus the left edge.
+        tools::Long nLeft = rParm.rOld.GetLeft();
+        const  SwTableBox  *pCur  = pBox;
+        const  SwTableLine *pLine = pBox->GetUpper();
+
+        while ( pLine )
+        {
+            const SwTableBoxes &rBoxes = pLine->GetTabBoxes();
+            for ( size_t i = 0; (i < rBoxes.size()) && (rBoxes[i] != pCur); ++i)
+            {
+                nLeft += lcl_MulDiv64<tools::Long>(
+                    rBoxes[i]->GetFrameFormat()->GetFrameSize().GetWidth(),
+                    nOldAct, rParm.nOldWish);
+            }
+            pCur  = pLine->GetUpper();
+            pLine = pCur ? pCur->GetUpper() : nullptr;
+        }
+        tools::Long nLeftDiff = 0;
+        tools::Long nRightDiff = 0;
+        if ( nLeft != rParm.rOld.GetLeft() ) // There are still boxes before this.
+        {
+            // Right edge is left edge plus width.
+            const tools::Long nWidth = lcl_MulDiv64<tools::Long>(
+                pBox->GetFrameFormat()->GetFrameSize().GetWidth(),
+                nOldAct, rParm.nOldWish);
+            const tools::Long nRight = nLeft + nWidth;
+            size_t nLeftPos  = 0;
+            size_t nRightPos = 0;
+            bool bFoundLeftPos = false;
+            bool bFoundRightPos = false;
+            for ( size_t i = 0; i < rParm.rOld.Count(); ++i )
+            {
+                if ( nLeft >= (rParm.rOld[i] - COLFUZZY) &&
+                     nLeft <= (rParm.rOld[i] + COLFUZZY) )
+                {
+                    nLeftPos = i;
+                    bFoundLeftPos = true;
+                }
+                else if ( nRight >= (rParm.rOld[i] - COLFUZZY) &&
+                          nRight <= (rParm.rOld[i] + COLFUZZY) )
+                {
+                    nRightPos = i;
+                    bFoundRightPos = true;
+                }
+            }
+            nLeftDiff = bFoundLeftPos ?
+                rParm.rOld[nLeftPos] - rParm.rNew[nLeftPos] : 0;
+            nRightDiff= bFoundRightPos ?
+                rParm.rNew[nRightPos] - rParm.rOld[nRightPos] : 0;
+        }
+        else    // The first box.
+        {
+            nLeftDiff = rParm.rOld.GetLeft() - rParm.rNew.GetLeft();
+            if ( rParm.rOld.Count() )
+            {
+                // Calculate the difference to the edge touching the first box.
+                const tools::Long nWidth = lcl_MulDiv64<tools::Long>(
+                    pBox->GetFrameFormat()->GetFrameSize().GetWidth(),
+                    nOldAct, rParm.nOldWish);
+                const tools::Long nTmp = nWidth + rParm.rOld.GetLeft();
+                for ( size_t i = 0; i < rParm.rOld.Count(); ++i )
+                {
+                    if ( nTmp >= (rParm.rOld[i] - COLFUZZY) &&
+                         nTmp <= (rParm.rOld[i] + COLFUZZY) )
+                    {
+                        nRightDiff = rParm.rNew[i] - rParm.rOld[i];
+                        break;
+                    }
+                }
+            }
+        }
+
+        if( pBox->getRowSpan() == 1 )
+        {
+            const sal_uInt16 nPos = pBox->GetUpper()->GetBoxPos( pBox );
+            SwTableBoxes& rTableBoxes = pBox->GetUpper()->GetTabBoxes();
+            if( nPos && rTableBoxes[ nPos - 1 ]->getRowSpan() != 1 )
+                nLeftDiff = 0;
+            if( nPos + 1 < o3tl::narrowing<sal_uInt16>(rTableBoxes.size()) &&
+                rTableBoxes[ nPos + 1 ]->getRowSpan() != 1 )
+                nRightDiff = 0;
+        }
+        else
+            nLeftDiff = nRightDiff = 0;
+
+        if ( nLeftDiff || nRightDiff )
+        {
+            // The difference is the actual difference amount. For stretched
+            // tables, it does not make sense to adjust the attributes of the
+            // boxes by this amount. The difference amount needs to be converted
+            // accordingly.
+            tools::Long nTmp = rParm.rNew.GetRight() - rParm.rNew.GetLeft(); // +1 why?
+            nLeftDiff *= rParm.nNewWish;
+            nLeftDiff /= nTmp;
+            nRightDiff *= rParm.nNewWish;
+            nRightDiff /= nTmp;
+            tools::Long nDiff = nLeftDiff + nRightDiff;
+
+            // Adjust the box and all superiors by the difference amount.
+            while ( pBox )
+            {
+                SwFormatFrameSize aFormatFrameSize( pBox->GetFrameFormat()->GetFrameSize() );
+                aFormatFrameSize.SetWidth( aFormatFrameSize.GetWidth() + nDiff );
+                if ( aFormatFrameSize.GetWidth() < 0 )
+                    aFormatFrameSize.SetWidth( -aFormatFrameSize.GetWidth() );
+                rParm.aShareFormats.SetSize( *pBox, aFormatFrameSize );
+
+                // The outer cells of the last row are responsible to adjust a surrounding cell.
+                // Last line check:
+                if ( pBox->GetUpper()->GetUpper() &&
+                     pBox->GetUpper() != pBox->GetUpper()->GetUpper()->GetTabLines().back())
+                {
+                    pBox = nullptr;
+                }
+                else
+                {
+                    // Middle cell check:
+                    if ( pBox != pBox->GetUpper()->GetTabBoxes().front() )
+                        nDiff = nRightDiff;
+
+                    if ( pBox != pBox->GetUpper()->GetTabBoxes().back() )
+                        nDiff -= nRightDiff;
+
+                    pBox = nDiff ? pBox->GetUpper()->GetUpper() : nullptr;
+                }
+            }
+        }
+    }
+}
+
+static void lcl_ProcessBoxPtr( SwTableBox *pBox, std::deque<SwTableBox*> &rBoxArr,
+                           bool bBefore )
+{
+    if ( !pBox->GetTabLines().empty() )
+    {
+        const SwTableLines &rLines = pBox->GetTabLines();
+        for ( size_t i = 0; i < rLines.size(); ++i )
+        {
+            const SwTableBoxes &rBoxes = rLines[i]->GetTabBoxes();
+            for ( size_t j = 0; j < rBoxes.size(); ++j )
+                ::lcl_ProcessBoxPtr( rBoxes[j], rBoxArr, bBefore );
+        }
+    }
+    else if ( bBefore )
+        rBoxArr.push_front( pBox );
+    else
+        rBoxArr.push_back( pBox );
+}
+
+static void lcl_AdjustBox( SwTableBox *pBox, const tools::Long nDiff, Parm &rParm );
+
+static void lcl_AdjustLines( SwTableLines &rLines, const tools::Long nDiff, Parm &rParm )
+{
+    for ( size_t i = 0; i < rLines.size(); ++i )
+    {
+        SwTableBox *pBox = rLines[i]->GetTabBoxes()
+                                [rLines[i]->GetTabBoxes().size()-1];
+        lcl_AdjustBox( pBox, nDiff, rParm );
+    }
+}
+
+static void lcl_AdjustBox( SwTableBox *pBox, const tools::Long nDiff, Parm &rParm )
+{
+    if ( !pBox->GetTabLines().empty() )
+        ::lcl_AdjustLines( pBox->GetTabLines(), nDiff, rParm );
+
+    // Adjust the size of the box.
+    SwFormatFrameSize aFormatFrameSize( pBox->GetFrameFormat()->GetFrameSize() );
+    aFormatFrameSize.SetWidth( aFormatFrameSize.GetWidth() + nDiff );
+
+    rParm.aShareFormats.SetSize( *pBox, aFormatFrameSize );
+}
+
+void SwTable::SetTabCols( const SwTabCols &rNew, const SwTabCols &rOld,
+                          const SwTableBox *pStart, bool bCurRowOnly )
+{
+    CHECK_TABLE( *this )
+
+    SetHTMLTableLayout(std::shared_ptr<SwHTMLTableLayout>());    // delete HTML-Layout
+
+    // FME: Made rOld const. The caller is responsible for passing correct
+    // values of rOld. Therefore we do not have to call GetTabCols anymore:
+    //GetTabCols( rOld, pStart );
+
+    Parm aParm( rNew, rOld );
+
+    OSL_ENSURE( rOld.Count() == rNew.Count(), "Number of columns changed.");
+
+    // Convert the edges. We need to adjust the size of the table and some boxes.
+    // For the size adjustment, we must not make use of the Modify, since that'd
+    // adjust all boxes, which we really don't want.
+    SwFrameFormat *pFormat = GetFrameFormat();
+    aParm.nOldWish = aParm.nNewWish = pFormat->GetFrameSize().GetWidth();
+    if ( (rOld.GetLeft() != rNew.GetLeft()) ||
+         (rOld.GetRight()!= rNew.GetRight()) )
+    {
+        LockModify();
+        {
+            SvxLRSpaceItem aLR( pFormat->GetLRSpace() );
+            SvxShadowItem aSh( pFormat->GetShadow() );
+
+            SwTwips nShRight = aSh.CalcShadowSpace( SvxShadowItemSide::RIGHT );
+            SwTwips nShLeft = aSh.CalcShadowSpace( SvxShadowItemSide::LEFT );
+
+            aLR.SetLeft ( rNew.GetLeft() - nShLeft );
+            aLR.SetRight( rNew.GetRightMax() - rNew.GetRight() - nShRight );
+            pFormat->SetFormatAttr( aLR );
+
+            // The alignment of the table needs to be adjusted accordingly.
+            // This is done by preserving the exact positions that have been
+            // set by the user.
+            SwFormatHoriOrient aOri( pFormat->GetHoriOrient() );
+            if( text::HoriOrientation::NONE != aOri.GetHoriOrient() &&
+                text::HoriOrientation::CENTER != aOri.GetHoriOrient() )
+            {
+                const bool bLeftDist = rNew.GetLeft() != nShLeft;
+                const bool bRightDist = rNew.GetRight() + nShRight != rNew.GetRightMax();
+                if(!bLeftDist && !bRightDist)
+                    aOri.SetHoriOrient( text::HoriOrientation::FULL );
+                else if(!bRightDist && rNew.GetLeft() > nShLeft )
+                    aOri.SetHoriOrient( text::HoriOrientation::RIGHT );
+                else if(!bLeftDist && rNew.GetRight() + nShRight < rNew.GetRightMax())
+                    aOri.SetHoriOrient( text::HoriOrientation::LEFT );
+                else
+                {
+                    // if an automatic table hasn't (really) changed size, then leave it as auto.
+                    const tools::Long nOldWidth = rOld.GetRight() - rOld.GetLeft();
+                    const tools::Long nNewWidth = rNew.GetRight() - rNew.GetLeft();
+                    if (aOri.GetHoriOrient() != text::HoriOrientation::FULL
+                        || std::abs(nOldWidth - nNewWidth) > COLFUZZY)
+                    {
+                        aOri.SetHoriOrient(text::HoriOrientation::LEFT_AND_WIDTH);
+                    }
+                }
+            }
+            pFormat->SetFormatAttr( aOri );
+        }
+        const tools::Long nAct = rOld.GetRight() - rOld.GetLeft(); // +1 why?
+        tools::Long nTabDiff = 0;
+
+        if ( rOld.GetLeft() != rNew.GetLeft() )
+        {
+            nTabDiff = rOld.GetLeft() - rNew.GetLeft();
+            nTabDiff *= aParm.nOldWish;
+            nTabDiff /= nAct;
+        }
+        if ( rOld.GetRight() != rNew.GetRight() )
+        {
+            tools::Long nDiff = rNew.GetRight() - rOld.GetRight();
+            nDiff *= aParm.nOldWish;
+            nDiff /= nAct;
+            nTabDiff += nDiff;
+            if( !IsNewModel() )
+                ::lcl_AdjustLines( GetTabLines(), nDiff, aParm );
+        }
+
+        // Adjust the size of the table, watch out for stretched tables.
+        if ( nTabDiff )
+        {
+            aParm.nNewWish += nTabDiff;
+            if ( aParm.nNewWish < 0 )
+                aParm.nNewWish = USHRT_MAX; // Oops! Have to roll back.
+            SwFormatFrameSize aSz( pFormat->GetFrameSize() );
+            if ( aSz.GetWidth() != aParm.nNewWish )
+            {
+                aSz.SetWidth( aParm.nNewWish );
+                aSz.SetWidthPercent( 0 );
+                pFormat->SetFormatAttr( aSz );
+            }
+        }
+        UnlockModify();
+    }
+
+    if( IsNewModel() )
+        NewSetTabCols( aParm, rNew, rOld, pStart, bCurRowOnly );
+    else
+    {
+        if ( bCurRowOnly )
+        {
+            // To adjust the current row, we need to process all its boxes,
+            // similar to the filling of the TabCols (see GetTabCols()).
+            // Unfortunately we again have to take care to adjust the boxes
+            // from back to front, respectively from outer to inner.
+            // The best way to achieve this is probably to track the boxes
+            // in a PtrArray.
+            const SwTableBoxes &rBoxes = pStart->GetUpper()->GetTabBoxes();
+            for ( size_t i = 0; i < rBoxes.size(); ++i )
+                ::lcl_ProcessBoxPtr( rBoxes[i], aParm.aBoxArr, false );
+
+            const SwTableLine *pLine = pStart->GetUpper()->GetUpper() ?
+                                    pStart->GetUpper()->GetUpper()->GetUpper() : nullptr;
+            const SwTableBox  *pExcl = pStart->GetUpper()->GetUpper();
+            while ( pLine )
+            {
+                const SwTableBoxes &rBoxes2 = pLine->GetTabBoxes();
+                bool bBefore = true;
+                for ( size_t i = 0; i < rBoxes2.size(); ++i )
+                {
+                    if ( rBoxes2[i] != pExcl )
+                        ::lcl_ProcessBoxPtr( rBoxes2[i], aParm.aBoxArr, bBefore );
+                    else
+                        bBefore = false;
+                }
+                pExcl = pLine->GetUpper();
+                pLine = pLine->GetUpper() ? pLine->GetUpper()->GetUpper() : nullptr;
+            }
+            // After we've inserted a bunch of boxes (hopefully all and in
+            // correct order), we just need to process them in reverse order.
+            for ( int j = aParm.aBoxArr.size()-1; j >= 0; --j )
+            {
+                SwTableBox *pBox = aParm.aBoxArr[j];
+                ::lcl_ProcessBoxSet( pBox, aParm );
+            }
+        }
+        else
+        {
+            // Adjusting the entire table is 'easy'. All boxes without lines are
+            // adjusted, as are their superiors. Of course we need to process
+            // in reverse order to prevent fooling ourselves!
+            SwTableLines &rLines = GetTabLines();
+            for ( size_t i = rLines.size(); i > 0; )
+            {
+                --i;
+                ::lcl_ProcessLine( rLines[i], aParm );
+            }
+        }
+    }
+
+#ifdef DBG_UTIL
+    {
+        // do some checking for correct table widths
+        SwTwips nSize = GetFrameFormat()->GetFrameSize().GetWidth();
+        for (size_t n = 0; n < m_aLines.size(); ++n)
+        {
+            CheckBoxWidth( *m_aLines[ n ], nSize );
+        }
+    }
+#endif
+}
+
+typedef std::pair<sal_uInt16, sal_uInt16> ColChange;
+typedef std::list< ColChange > ChangeList;
+
+static void lcl_AdjustWidthsInLine( SwTableLine* pLine, ChangeList& rOldNew,
+    Parm& rParm, sal_uInt16 nColFuzzy )
+{
+    ChangeList::iterator pCurr = rOldNew.begin();
+    if( pCurr == rOldNew.end() )
+        return;
+    const size_t nCount = pLine->GetTabBoxes().size();
+    SwTwips nBorder = 0;
+    SwTwips nRest = 0;
+    for( size_t i = 0; i < nCount; ++i )
+    {
+        SwTableBox* pBox = pLine->GetTabBoxes()[i];
+        SwTwips nWidth = pBox->GetFrameFormat()->GetFrameSize().GetWidth();
+        SwTwips nNewWidth = nWidth - nRest;
+        nRest = 0;
+        nBorder += nWidth;
+        if( pCurr != rOldNew.end() && nBorder + nColFuzzy >= pCurr->first )
+        {
+            nBorder -= nColFuzzy;
+            while( pCurr != rOldNew.end() && nBorder > pCurr->first )
+                ++pCurr;
+            if( pCurr != rOldNew.end() )
+            {
+                nBorder += nColFuzzy;
+                if( nBorder + nColFuzzy >= pCurr->first )
+                {
+                    if( pCurr->second == pCurr->first )
+                        nRest = 0;
+                    else
+                        nRest = pCurr->second - nBorder;
+                    nNewWidth += nRest;
+                    ++pCurr;
+                }
+            }
+        }
+        if( nNewWidth != nWidth )
+        {
+            if( nNewWidth < 0 )
+            {
+                nRest += 1 - nNewWidth;
+                nNewWidth = 1;
+            }
+            SwFormatFrameSize aFormatFrameSize( pBox->GetFrameFormat()->GetFrameSize() );
+            aFormatFrameSize.SetWidth( nNewWidth );
+            rParm.aShareFormats.SetSize( *pBox, aFormatFrameSize );
+        }
+    }
+}
+
+static void lcl_CalcNewWidths( std::vector<sal_uInt16> &rSpanPos, ChangeList& rChanges,
+    SwTableLine* pLine, tools::Long nWish, tools::Long nWidth, bool bTop )
+{
+    if( rChanges.empty() )
+    {
+        rSpanPos.clear();
+        return;
+    }
+    if( rSpanPos.empty() )
+    {
+        rChanges.clear();
+        return;
+    }
+    std::vector<sal_uInt16> aNewSpanPos;
+    ChangeList::iterator pCurr = rChanges.begin();
+    ChangeList aNewChanges { *pCurr }; // Nullposition
+    std::vector<sal_uInt16>::iterator pSpan = rSpanPos.begin();
+    sal_uInt16 nCurr = 0;
+    SwTwips nOrgSum = 0;
+    bool bRowSpan = false;
+    sal_uInt16 nRowSpanCount = 0;
+    const size_t nCount = pLine->GetTabBoxes().size();
+    for( size_t nCurrBox = 0; nCurrBox < nCount; ++nCurrBox )
+    {
+        SwTableBox* pBox = pLine->GetTabBoxes()[nCurrBox];
+        SwTwips nCurrWidth = pBox->GetFrameFormat()->GetFrameSize().GetWidth();
+        const sal_Int32 nRowSpan = pBox->getRowSpan();
+        const bool bCurrRowSpan = bTop ? nRowSpan < 0 :
+            ( nRowSpan > 1 || nRowSpan < -1 );
+        if( bRowSpan || bCurrRowSpan )
+            aNewSpanPos.push_back( nRowSpanCount );
+        bRowSpan = bCurrRowSpan;
+        nOrgSum += nCurrWidth;
+        const sal_uInt16 nPos = lcl_MulDiv64<sal_uInt16>(
+            lcl_MulDiv64<sal_uInt64>(nOrgSum, nWidth, nWish),
+            nWish, nWidth);
+        while( pCurr != rChanges.end() && pCurr->first < nPos )
+        {
+            ++nCurr;
+            ++pCurr;
+        }
+        bool bNew = true;
+        if( pCurr != rChanges.end() && pCurr->first <= nPos &&
+            pCurr->first != pCurr->second )
+        {
+            pSpan = std::find_if(pSpan, rSpanPos.end(),
+                [nCurr](const sal_uInt16 nSpan) { return nSpan >= nCurr; });
+            if( pSpan != rSpanPos.end() && *pSpan == nCurr )
+            {
+                aNewChanges.push_back( *pCurr );
+                ++nRowSpanCount;
+                bNew = false;
+            }
+        }
+        if( bNew )
+        {
+            ColChange aTmp( nPos, nPos );
+            aNewChanges.push_back( aTmp );
+            ++nRowSpanCount;
+        }
+    }
+
+    pCurr = aNewChanges.begin();
+    ChangeList::iterator pLast = pCurr;
+    ChangeList::iterator pLeftMove = pCurr;
+    while( pCurr != aNewChanges.end() )
+    {
+        if( pLeftMove == pCurr )
+        {
+            while( ++pLeftMove != aNewChanges.end() && pLeftMove->first <= pLeftMove->second )
+                ;
+        }
+        if( pCurr->second == pCurr->first )
+        {
+            if( pLeftMove != aNewChanges.end() && pCurr->second > pLeftMove->second )
+            {
+                if( pLeftMove->first == pLast->first )
+                    pCurr->second = pLeftMove->second;
+                else
+                {
+                    pCurr->second = lcl_MulDiv64<sal_uInt16>(
+                        pCurr->first - pLast->first,
+                        pLeftMove->second - pLast->second,
+                        pLeftMove->first - pLast->first) + pLast->second;
+                }
+            }
+            pLast = pCurr;
+            ++pCurr;
+        }
+        else if( pCurr->second > pCurr->first )
+        {
+            pLast = pCurr;
+            ++pCurr;
+            ChangeList::iterator pNext = pCurr;
+            while( pNext != pLeftMove && pNext->second == pNext->first &&
+                pNext->second < pLast->second )
+                ++pNext;
+            while( pCurr != pNext )
+            {
+                if( pNext == aNewChanges.end() || pNext->first == pLast->first )
+                    pCurr->second = pLast->second;
+                else
+                {
+                    pCurr->second = lcl_MulDiv64<sal_uInt16>(
+                        pCurr->first - pLast->first,
+                        pNext->second - pLast->second,
+                        pNext->first - pLast->first) + pLast->second;
+                }
+                ++pCurr;
+            }
+            pLast = pCurr;
+        }
+        else
+        {
+            pLast = pCurr;
+            ++pCurr;
+        }
+    }
+
+    rChanges.swap(aNewChanges);
+    rSpanPos.swap(aNewSpanPos);
+}
+
+void SwTable::NewSetTabCols( Parm &rParm, const SwTabCols &rNew,
+    const SwTabCols &rOld, const SwTableBox *pStart, bool bCurRowOnly )
+{
+#if OSL_DEBUG_LEVEL > 1
+    static int nCallCount = 0;
+    ++nCallCount;
+#endif
+    // First step: evaluate which lines have been moved/which widths changed
+    ChangeList aOldNew;
+    const tools::Long nNewWidth = rParm.rNew.GetRight() - rParm.rNew.GetLeft();
+    const tools::Long nOldWidth = rParm.rOld.GetRight() - rParm.rOld.GetLeft();
+    if( nNewWidth < 1 || nOldWidth < 1 )
+        return;
+    for( size_t i = 0; i <= rOld.Count(); ++i )
+    {
+        tools::Long nNewPos;
+        tools::Long nOldPos;
+        if( i == rOld.Count() )
+        {
+            nOldPos = rParm.rOld.GetRight() - rParm.rOld.GetLeft();
+            nNewPos = rParm.rNew.GetRight() - rParm.rNew.GetLeft();
+        }
+        else
+        {
+            nOldPos = rOld[i] - rParm.rOld.GetLeft();
+            nNewPos = rNew[i] - rParm.rNew.GetLeft();
+        }
+        nNewPos = lcl_MulDiv64<tools::Long>(nNewPos, rParm.nNewWish, nNewWidth);
+        nOldPos = lcl_MulDiv64<tools::Long>(nOldPos, rParm.nOldWish, nOldWidth);
+        if( nOldPos != nNewPos && nNewPos > 0 && nOldPos > 0 )
+        {
+            ColChange aChg( o3tl::narrowing<sal_uInt16>(nOldPos), o3tl::narrowing<sal_uInt16>(nNewPos) );
+            aOldNew.push_back( aChg );
+        }
+    }
+    // Finished first step
+    int nCount = aOldNew.size();
+    if( !nCount )
+        return; // no change, nothing to do
+    SwTableLines &rLines = GetTabLines();
+    if( bCurRowOnly )
+    {
+        const SwTableLine* pCurrLine = pStart->GetUpper();
+        sal_uInt16 nCurr = rLines.GetPos( pCurrLine );
+        if( nCurr >= USHRT_MAX )
+            return;
+
+        ColChange aChg( 0, 0 );
+        aOldNew.push_front( aChg );
+        std::vector<sal_uInt16> aRowSpanPos;
+        if( nCurr )
+        {
+            ChangeList aCopy;
+            sal_uInt16 nPos = 0;
+            for( const auto& rCop : aOldNew )
+            {
+                aCopy.push_back( rCop );
+                aRowSpanPos.push_back( nPos++ );
+            }
+            lcl_CalcNewWidths( aRowSpanPos, aCopy, rLines[nCurr],
+                rParm.nOldWish, nOldWidth, true );
+            bool bGoOn = !aRowSpanPos.empty();
+            sal_uInt16 j = nCurr;
+            while( bGoOn )
+            {
+                lcl_CalcNewWidths( aRowSpanPos, aCopy, rLines[--j],
+                    rParm.nOldWish, nOldWidth, true );
+                lcl_AdjustWidthsInLine( rLines[j], aCopy, rParm, 0 );
+                bGoOn = !aRowSpanPos.empty() && j > 0;
+            }
+            aRowSpanPos.clear();
+        }
+        if( nCurr+1 < o3tl::narrowing<sal_uInt16>(rLines.size()) )
+        {
+            ChangeList aCopy;
+            sal_uInt16 nPos = 0;
+            for( const auto& rCop : aOldNew )
+            {
+                aCopy.push_back( rCop );
+                aRowSpanPos.push_back( nPos++ );
+            }
+            lcl_CalcNewWidths( aRowSpanPos, aCopy, rLines[nCurr],
+                rParm.nOldWish, nOldWidth, false );
+            bool bGoOn = !aRowSpanPos.empty();
+            sal_uInt16 j = nCurr;
+            while( bGoOn )
+            {
+                lcl_CalcNewWidths( aRowSpanPos, aCopy, rLines[++j],
+                    rParm.nOldWish, nOldWidth, false );
+                lcl_AdjustWidthsInLine( rLines[j], aCopy, rParm, 0 );
+                bGoOn = !aRowSpanPos.empty() && j+1 < o3tl::narrowing<sal_uInt16>(rLines.size());
+            }
+        }
+        ::lcl_AdjustWidthsInLine( rLines[nCurr], aOldNew, rParm, COLFUZZY );
+    }
+    else
+    {
+        for( size_t i = 0; i < rLines.size(); ++i )
+            ::lcl_AdjustWidthsInLine( rLines[i], aOldNew, rParm, COLFUZZY );
+    }
+    CHECK_TABLE( *this )
+}
+
+// return the pointer of the box specified.
+static bool lcl_IsValidRowName( std::u16string_view rStr )
+{
+    bool bIsValid = true;
+    size_t nLen = rStr.size();
+    for( size_t i = 0;  i < nLen && bIsValid; ++i )
+    {
+        const sal_Unicode cChar = rStr[i];
+        if (cChar < '0' || cChar > '9')
+            bIsValid = false;
+    }
+    return bIsValid;
+}
+
+// #i80314#
+// add 3rd parameter and its handling
+sal_uInt16 SwTable::GetBoxNum( OUString& rStr, bool bFirstPart,
+                            const bool bPerformValidCheck )
+{
+    sal_uInt16 nRet = 0;
+    if( bFirstPart )   // true == column; false == row
+    {
+        sal_Int32 nPos = 0;
+        // the first one uses letters for addressing!
+        bool bFirst = true;
+        sal_uInt32 num = 0;
+        bool overflow = false;
+        while (nPos<rStr.getLength())
+        {
+            sal_Unicode cChar = rStr[nPos];
+            if ((cChar<'A' || cChar>'Z') && (cChar<'a' || cChar>'z'))
+                break;
+            cChar -= 'A';
+            if( cChar >= 26 )
+                cChar -= 'a' - '[';
+            if( bFirst )
+                bFirst = false;
+            else
+                ++num;
+            num = num * 52 + cChar;
+            if (num > SAL_MAX_UINT16) {
+                overflow = true;
+            }
+            ++nPos;
+        }
+        nRet = overflow ? SAL_MAX_UINT16 : num;
+        rStr = rStr.copy( nPos );      // Remove char from String
+    }
+    else
+    {
+        const sal_Int32 nPos = rStr.indexOf( "." );
+        if ( nPos<0 )
+        {
+            nRet = 0;
+            if ( !bPerformValidCheck || lcl_IsValidRowName( rStr ) )
+            {
+                nRet = o3tl::narrowing<sal_uInt16>(rStr.toInt32());
+            }
+            rStr.clear();
+        }
+        else
+        {
+            nRet = 0;
+            const std::u16string_view aText( rStr.subView( 0, nPos ) );
+            if ( !bPerformValidCheck || lcl_IsValidRowName( aText ) )
+            {
+                nRet = o3tl::narrowing<sal_uInt16>(o3tl::toInt32(aText));
+            }
+            rStr = rStr.copy( nPos+1 );
+        }
+    }
+    return nRet;
+}
+
+// #i80314#
+// add 2nd parameter and its handling
+const SwTableBox* SwTable::GetTableBox( const OUString& rName,
+                                      const bool bPerformValidCheck ) const
+{
+    const SwTableBox* pBox = nullptr;
+    const SwTableLine* pLine;
+    const SwTableLines* pLines;
+
+    sal_uInt16 nLine, nBox;
+    OUString aNm( rName );
+    while( !aNm.isEmpty() )
+    {
+        nBox = SwTable::GetBoxNum( aNm, nullptr == pBox, bPerformValidCheck );
+        // first box ?
+        if( !pBox )
+            pLines = &GetTabLines();
+        else
+        {
+            pLines = &pBox->GetTabLines();
+            if( nBox )
+                --nBox;
+        }
+
+        nLine = SwTable::GetBoxNum( aNm, false, bPerformValidCheck );
+
+        // determine line
+        if( !nLine || nLine > pLines->size() )
+            return nullptr;
+        pLine = (*pLines)[ nLine-1 ];
+
+        // determine box
+        const SwTableBoxes* pBoxes = &pLine->GetTabBoxes();
+        if( nBox >= pBoxes->size() )
+            return nullptr;
+        pBox = (*pBoxes)[ nBox ];
+    }
+
+    // check if the box found has any contents
+    if( pBox && !pBox->GetSttNd() )
+    {
+        OSL_FAIL( "Box without content, looking for the next one!" );
+        // "drop this" until the first box
+        while( !pBox->GetTabLines().empty() )
+            pBox = pBox->GetTabLines().front()->GetTabBoxes().front();
+    }
+    return pBox;
+}
+
+SwTableBox* SwTable::GetTableBox( SwNodeOffset nSttIdx )
+{
+    // For optimizations, don't always process the entire SortArray.
+    // Converting text to table, tries certain conditions
+    // to ask for a table box of a table that is not yet having a format
+    if(!GetFrameFormat())
+        return nullptr;
+    SwTableBox* pRet = nullptr;
+    SwNodes& rNds = GetFrameFormat()->GetDoc()->GetNodes();
+    SwNodeOffset nIndex = nSttIdx + 1;
+    SwContentNode* pCNd = nullptr;
+    SwTableNode* pTableNd = nullptr;
+
+    while ( nIndex < rNds.Count() )
+    {
+        pTableNd = rNds[ nIndex ]->GetTableNode();
+        if ( pTableNd )
+            break;
+
+        pCNd = rNds[ nIndex ]->GetContentNode();
+        if ( pCNd )
+            break;
+
+        ++nIndex;
+    }
+
+    if ( pCNd || pTableNd )
+    {
+        sw::BroadcastingModify* pModify = pCNd;
+        // #144862# Better handling of table in table
+        if ( pTableNd && pTableNd->GetTable().GetFrameFormat() )
+            pModify = pTableNd->GetTable().GetFrameFormat();
+
+        SwFrame* pFrame = pModify ? SwIterator<SwFrame,sw::BroadcastingModify>(*pModify).First() : nullptr;
+        while ( pFrame && !pFrame->IsCellFrame() )
+            pFrame = pFrame->GetUpper();
+        if ( pFrame )
+            pRet = const_cast<SwTableBox*>(static_cast<SwCellFrame*>(pFrame)->GetTabBox());
+    }
+
+    // In case the layout doesn't exist yet or anything else goes wrong.
+    if ( !pRet )
+    {
+        for (size_t n = m_TabSortContentBoxes.size(); n; )
+        {
+            if (m_TabSortContentBoxes[ --n ]->GetSttIdx() == nSttIdx)
+            {
+                return m_TabSortContentBoxes[ n ];
+            }
+        }
+    }
+    return pRet;
+}
+
+bool SwTable::IsTableComplex() const
+{
+    // Returns true for complex tables, i.e. tables that contain nestings,
+    // like containing boxes not part of the first line, e.g. results of
+    // splits/merges which lead to more complex structures.
+    for (size_t n = 0; n < m_TabSortContentBoxes.size(); ++n)
+    {
+        if (m_TabSortContentBoxes[ n ]->GetUpper()->GetUpper())
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+SwTableLine::SwTableLine( SwTableLineFormat *pFormat, sal_uInt16 nBoxes,
+                            SwTableBox *pUp )
+    : SwClient( pFormat )
+    , m_pUpper( pUp )
+    , m_eRedlineType( RedlineType::None )
+{
+    m_aBoxes.reserve( nBoxes );
+}
+
+SwTableLine::~SwTableLine()
+{
+    for (size_t i = 0; i < m_aBoxes.size(); ++i)
+    {
+        delete m_aBoxes[i];
+    }
+    // the TabelleLine can be deleted if it's the last client of the FrameFormat
+    sw::BroadcastingModify* pMod = GetFrameFormat();
+    pMod->Remove( this );               // remove,
+    if( !pMod->HasWriterListeners() )
+        delete pMod;    // and delete
+}
+
+SwFrameFormat* SwTableLine::ClaimFrameFormat()
+{
+    // This method makes sure that this object is an exclusive SwTableLine client
+    // of an SwTableLineFormat object
+    // If other SwTableLine objects currently listen to the same SwTableLineFormat as
+    // this one, something needs to be done
+    SwTableLineFormat *pRet = static_cast<SwTableLineFormat*>(GetFrameFormat());
+    SwIterator<SwTableLine,SwFormat> aIter( *pRet );
+    for( SwTableLine* pLast = aIter.First(); pLast; pLast = aIter.Next() )
+    {
+        if ( pLast != this )
+        {
+            // found another SwTableLine that is a client of the current Format
+            // create a new Format as a copy and use it for this object
+            SwTableLineFormat *pNewFormat = pRet->GetDoc()->MakeTableLineFormat();
+            *pNewFormat = *pRet;
+
+            // register SwRowFrames that know me as clients at the new Format
+            SwIterator<SwRowFrame,SwFormat> aFrameIter( *pRet );
+            for( SwRowFrame* pFrame = aFrameIter.First(); pFrame; pFrame = aFrameIter.Next() )
+                if( pFrame->GetTabLine() == this )
+                    pFrame->RegisterToFormat( *pNewFormat );
+
+            // register myself
+            pNewFormat->Add( this );
+            pRet = pNewFormat;
+            break;
+        }
+    }
+
+    return pRet;
+}
+
+void SwTableLine::ChgFrameFormat(SwTableLineFormat* pNewFormat)
+{
+    auto pOld = GetFrameFormat();
+    pOld->CallSwClientNotify(sw::TableLineFormatChanged(*pNewFormat, *this));
+    // Now, re-register self.
+    pNewFormat->Add(this);
+    if(!pOld->HasWriterListeners())
+        delete pOld;
+}
+
+SwTwips SwTableLine::GetTableLineHeight( bool& bLayoutAvailable ) const
+{
+    SwTwips nRet = 0;
+    bLayoutAvailable = false;
+    SwIterator<SwRowFrame,SwFormat> aIter( *GetFrameFormat() );
+    // A row could appear several times in headers/footers so only one chain of master/follow tables
+    // will be accepted...
+    const SwTabFrame* pChain = nullptr; // My chain
+    for( SwRowFrame* pLast = aIter.First(); pLast; pLast = aIter.Next() )
+    {
+        if( pLast->GetTabLine() == this )
+        {
+            const SwTabFrame* pTab = pLast->FindTabFrame();
+            bLayoutAvailable = ( pTab && pTab->IsVertical() ) ?
+                               ( 0 < pTab->getFrameArea().Height() ) :
+                               ( 0 < pTab->getFrameArea().Width() );
+
+            // The first one defines the chain, if a chain is defined, only members of the chain
+            // will be added.
+            if (pTab && (!pChain || pChain->IsAnFollow( pTab ) || pTab->IsAnFollow(pChain)))
+            {
+                pChain = pTab; // defines my chain (even it is already)
+                if( pTab->IsVertical() )
+                    nRet += pLast->getFrameArea().Width();
+                else
+                    nRet += pLast->getFrameArea().Height();
+                // Optimization, if there are no master/follows in my chain, nothing more to add
+                if( !pTab->HasFollow() && !pTab->IsFollow() )
+                    break;
+                // This is not an optimization, this is necessary to avoid double additions of
+                // repeating rows
+                if( pTab->IsInHeadline(*pLast) )
+                    break;
+            }
+        }
+    }
+    return nRet;
+}
+
+bool SwTableLine::IsEmpty() const
+{
+    for (size_t i = 0; i < m_aBoxes.size(); ++i)
+    {
+        if ( !m_aBoxes[i]->IsEmpty() )
+            return false;
+    }
+    return true;
+}
+
+bool SwTable::HasDeletedRow() const
+{
+    const SwRedlineTable& aRedlineTable = GetFrameFormat()->GetDoc()->getIDocumentRedlineAccess().GetRedlineTable();
+    if ( aRedlineTable.empty() )
+        return false;
+
+    SwRedlineTable::size_type nRedlinePos = 0;
+    for (size_t i = 0; i < m_aLines.size(); ++i)
+    {
+        if ( m_aLines[i]->IsDeleted(nRedlinePos) )
+            return true;
+    }
+    return false;
+}
+
+bool SwTable::IsDeleted() const
+{
+    const SwRedlineTable& aRedlineTable = GetFrameFormat()->GetDoc()->getIDocumentRedlineAccess().GetRedlineTable();
+    if ( aRedlineTable.empty() )
+        return false;
+
+    SwRedlineTable::size_type nRedlinePos = 0;
+    for (size_t i = 0; i < m_aLines.size(); ++i)
+    {
+        if ( !m_aLines[i]->IsDeleted(nRedlinePos) )
+            return false;
+    }
+    return true;
+}
+
+// TODO Set HasTextChangesOnly=true, if needed based on the redlines in the cells.
+// At tracked row deletion, return with the newest deletion of the row or
+// at tracked row insertion, return with the oldest insertion in the row, which
+// contain the change data of the row change.
+// If the return value is SwRedlineTable::npos, there is no tracked row change.
+SwRedlineTable::size_type SwTableLine::UpdateTextChangesOnly(
+    SwRedlineTable::size_type& rRedlinePos, bool bUpdateProperty ) const
+{
+    SwRedlineTable::size_type nRet = SwRedlineTable::npos;
+    const SwRedlineTable& aRedlineTable = GetFrameFormat()->GetDoc()->getIDocumentRedlineAccess().GetRedlineTable();
+
+    // check table row property "HasTextChangesOnly", if it's defined and its
+    // value is false, and all text content is in delete redlines, the row is deleted
+    const SvxPrintItem *pHasTextChangesOnlyProp =
+            GetFrameFormat()->GetAttrSet().GetItem<SvxPrintItem>(RES_PRINT);
+    if ( pHasTextChangesOnlyProp && !pHasTextChangesOnlyProp->GetValue() )
+    {
+        const SwTableBoxes & rBoxes = GetTabBoxes();
+        size_t nBoxes = rBoxes.size();
+        bool bInsertion = false;
+        bool bPlainTextInLine = false;
+        SwRedlineTable::size_type nOldestRedline = SwRedlineTable::npos;
+        SwRedlineTable::size_type nNewestRedline = SwRedlineTable::npos;
+        for (size_t nBoxIndex = 0; nBoxIndex < nBoxes && rRedlinePos < aRedlineTable.size(); ++nBoxIndex)
+        {
+            auto pBox = rBoxes[nBoxIndex];
+            if ( pBox->IsEmpty() )
+            {
+               // no text content, check the next cells
+               continue;
+            }
+
+            bool bHasRedlineInBox = false;
+            SwPosition aCellStart( SwNodeIndex( *pBox->GetSttNd(), 0 ) );
+            SwPosition aCellEnd( SwNodeIndex( *pBox->GetSttNd()->EndOfSectionNode(), -1 ) );
+            SwNodeIndex pEndNodeIndex(aCellEnd.nNode.GetNode());
+            SwRangeRedline* pPreviousDeleteRedline = nullptr;
+            for( ; rRedlinePos < aRedlineTable.size(); ++rRedlinePos )
+            {
+                const SwRangeRedline* pRedline = aRedlineTable[ rRedlinePos ];
+
+                if ( pRedline->Start()->nNode > pEndNodeIndex )
+                {
+                    // no more redlines in the actual cell,
+                    // check the next ones
+                    break;
+                }
+
+                // redline in the cell
+                if ( aCellStart <= *pRedline->Start() )
+                {
+                    if ( !bHasRedlineInBox )
+                    {
+                        bHasRedlineInBox = true;
+                        // plain text before the first redline in the text
+                        if ( pRedline->Start()->nContent.GetIndex() > 0 )
+                            bPlainTextInLine = true;
+                    }
+
+                    RedlineType nType = pRedline->GetType();
+
+                    // first insert redline
+                    if ( !bInsertion )
+                    {
+                        if ( RedlineType::Insert == nType )
+                        {
+                            bInsertion = true;
+                        }
+                        else
+                        {
+                            // plain text between the delete redlines
+                            if ( pPreviousDeleteRedline &&
+                                *pPreviousDeleteRedline->End() < *pRedline->Start() )
+                            {
+                                bPlainTextInLine = true;
+                            }
+                            pPreviousDeleteRedline = const_cast<SwRangeRedline*>(pRedline);
+                        }
+                    }
+
+                    // search newest and oldest redlines
+                    if ( nNewestRedline == SwRedlineTable::npos ||
+                             aRedlineTable[nNewestRedline]->GetRedlineData().GetTimeStamp() <
+                                 pRedline->GetRedlineData().GetTimeStamp() )
+                    {
+                        nNewestRedline = rRedlinePos;
+                    }
+                    if ( nOldestRedline == SwRedlineTable::npos ||
+                             aRedlineTable[nOldestRedline]->GetRedlineData().GetTimeStamp() >
+                                 pRedline->GetRedlineData().GetTimeStamp() )
+                    {
+                        nOldestRedline = rRedlinePos;
+                    }
+                }
+            }
+
+            // there is text content outside of redlines: not a deletion
+            if ( !bInsertion && ( !bHasRedlineInBox || ( pPreviousDeleteRedline &&
+                 ( pPreviousDeleteRedline->End()->nNode < aCellEnd.nNode ||
+                   pPreviousDeleteRedline->End()->nContent.GetIndex() <
+                           aCellEnd.nNode.GetNode().GetContentNode()->Len() ) ) ) )
+            {
+                bPlainTextInLine = true;
+                // not deleted cell content: the row is not empty
+                // maybe insertion of a row, try to search it
+                bInsertion = true;
+            }
+        }
+
+        // choose return redline, if it exists or remove changed row attribute
+        if ( bInsertion && SwRedlineTable::npos != nOldestRedline &&
+                RedlineType::Insert == aRedlineTable[ nOldestRedline ]->GetType() )
+        {
+            // there is an insert redline, which is the oldest redline in the row
+            nRet = nOldestRedline;
+        }
+        else if ( !bInsertion && !bPlainTextInLine && SwRedlineTable::npos != nNewestRedline &&
+                RedlineType::Delete == aRedlineTable[ nNewestRedline ]->GetType() )
+        {
+            // there is a delete redline, which is the newest redline in the row,
+            // and no text outside of redlines, and no insert redline in the row,
+            // i.e. whole text content is deleted
+            nRet = nNewestRedline;
+        }
+        else
+        {
+            // no longer tracked row insertion or deletion
+            nRet = SwRedlineTable::npos;
+            // set TextChangesOnly = true to remove the tracked deletion
+            // FIXME Undo is not supported here (this is only a fallback,
+            // because using SetRowNotTracked() is not recommended here)
+            if ( bUpdateProperty )
+            {
+                SvxPrintItem aUnsetTracking(RES_PRINT, true);
+                SwFrameFormat *pFormat = const_cast<SwTableLine*>(this)->ClaimFrameFormat();
+                pFormat->LockModify();
+                pFormat->SetFormatAttr( aUnsetTracking );
+                pFormat->UnlockModify();
+            }
+        }
+    }
+
+    // cache the result
+    const_cast<SwTableLine*>(this)->SetRedlineType( SwRedlineTable::npos == nRet
+        ? RedlineType::None
+        : aRedlineTable[ nRet ]->GetType());
+
+    return nRet;
+}
+
+bool SwTableLine::IsDeleted(SwRedlineTable::size_type& rRedlinePos) const
+{
+   SwRedlineTable::size_type nPos = UpdateTextChangesOnly(rRedlinePos);
+   if ( nPos != SwRedlineTable::npos )
+   {
+       const SwRedlineTable& aRedlineTable =
+           GetFrameFormat()->GetDoc()->getIDocumentRedlineAccess().GetRedlineTable();
+       if ( RedlineType::Delete == aRedlineTable[nPos]->GetType() )
+           return true;
+   }
+   return false;
+}
+
+RedlineType SwTableLine::GetRedlineType() const
+{
+    const SwRedlineTable& aRedlineTable = GetFrameFormat()->GetDoc()->getIDocumentRedlineAccess().GetRedlineTable();
+    if ( aRedlineTable.empty() )
+        return RedlineType::None;
+
+    // check table row property "HasTextChangesOnly", if it's defined and its value is
+    // false, return with the cached redline type, if it exists, otherwise calculate it
+    const SvxPrintItem *pHasTextChangesOnlyProp =
+            GetFrameFormat()->GetAttrSet().GetItem<SvxPrintItem>(RES_PRINT);
+    if ( pHasTextChangesOnlyProp && !pHasTextChangesOnlyProp->GetValue() )
+    {
+        if ( RedlineType::None != m_eRedlineType )
+            return m_eRedlineType;
+
+        SwRedlineTable::size_type nPos = 0;
+        nPos = UpdateTextChangesOnly(nPos);
+        if ( nPos != SwRedlineTable::npos )
+            return aRedlineTable[nPos]->GetType();
+    }
+    else if ( RedlineType::None != m_eRedlineType )
+        // empty the cache
+        const_cast<SwTableLine*>(this)->SetRedlineType( RedlineType::None );
+
+    return RedlineType::None;
+}
+
+SwTableBox::SwTableBox( SwTableBoxFormat* pFormat, sal_uInt16 nLines, SwTableLine *pUp )
+    : SwClient(nullptr)
+    , m_aLines()
+    , m_pStartNode(nullptr)
+    , m_pUpper(pUp)
+    , mnRowSpan(1)
+    , mbDummyFlag(false)
+    , mbDirectFormatting(false)
+{
+    m_aLines.reserve( nLines );
+    CheckBoxFormat( pFormat )->Add( this );
+}
+
+SwTableBox::SwTableBox( SwTableBoxFormat* pFormat, const SwNodeIndex &rIdx,
+                        SwTableLine *pUp )
+    : SwClient(nullptr)
+    , m_aLines()
+    , m_pUpper(pUp)
+    , mnRowSpan(1)
+    , mbDummyFlag(false)
+    , mbDirectFormatting(false)
+{
+    CheckBoxFormat( pFormat )->Add( this );
+
+    m_pStartNode = rIdx.GetNode().GetStartNode();
+
+    // insert into the table
+    const SwTableNode* pTableNd = m_pStartNode->FindTableNode();
+    assert(pTableNd && "In which table is that box?");
+    SwTableSortBoxes& rSrtArr = const_cast<SwTableSortBoxes&>(pTableNd->GetTable().
+                                GetTabSortBoxes());
+    SwTableBox* p = this;   // error: &this
+    rSrtArr.insert( p );        // insert
+}
+
+SwTableBox::SwTableBox( SwTableBoxFormat* pFormat, const SwStartNode& rSttNd, SwTableLine *pUp )
+    : SwClient(nullptr)
+    , m_aLines()
+    , m_pStartNode(&rSttNd)
+    , m_pUpper(pUp)
+    , mnRowSpan(1)
+    , mbDummyFlag(false)
+    , mbDirectFormatting(false)
+{
+    CheckBoxFormat( pFormat )->Add( this );
+
+    // insert into the table
+    const SwTableNode* pTableNd = m_pStartNode->FindTableNode();
+    OSL_ENSURE( pTableNd, "In which table is the box?" );
+    SwTableSortBoxes& rSrtArr = const_cast<SwTableSortBoxes&>(pTableNd->GetTable().
+                                GetTabSortBoxes());
+    SwTableBox* p = this;   // error: &this
+    rSrtArr.insert( p );        // insert
+}
+
+void SwTableBox::RemoveFromTable()
+{
+    if (m_pStartNode) // box containing contents?
+    {
+        // remove from table
+        const SwTableNode* pTableNd = m_pStartNode->FindTableNode();
+        assert(pTableNd && "In which table is that box?");
+        SwTableSortBoxes& rSrtArr = const_cast<SwTableSortBoxes&>(pTableNd->GetTable().
+                                    GetTabSortBoxes());
+        SwTableBox *p = this;   // error: &this
+        rSrtArr.erase( p );        // remove
+        m_pStartNode = nullptr; // clear it so this is only run once
+    }
+}
+
+SwTableBox::~SwTableBox()
+{
+    if (!GetFrameFormat()->GetDoc()->IsInDtor())
+    {
+        RemoveFromTable();
+    }
+
+    // the TabelleBox can be deleted if it's the last client of the FrameFormat
+    sw::BroadcastingModify* pMod = GetFrameFormat();
+    pMod->Remove( this );               // remove,
+    if( !pMod->HasWriterListeners() )
+        delete pMod;    // and delete
+}
+
+SwTableBoxFormat* SwTableBox::CheckBoxFormat( SwTableBoxFormat* pFormat )
+{
+    // We might need to create a new format here, because the box must be
+    // added to the format solely if pFormat has a value or form.
+    if( SfxItemState::SET == pFormat->GetItemState( RES_BOXATR_VALUE, false ) ||
+        SfxItemState::SET == pFormat->GetItemState( RES_BOXATR_FORMULA, false ) )
+    {
+        SwTableBox* pOther = SwIterator<SwTableBox,SwFormat>( *pFormat ).First();
+        if( pOther )
+        {
+            SwTableBoxFormat* pNewFormat = pFormat->GetDoc()->MakeTableBoxFormat();
+            pNewFormat->LockModify();
+            *pNewFormat = *pFormat;
+
+            // Remove values and formulas
+            pNewFormat->ResetFormatAttr( RES_BOXATR_FORMULA, RES_BOXATR_VALUE );
+            pNewFormat->UnlockModify();
+
+            pFormat = pNewFormat;
+        }
+    }
+    return pFormat;
+}
+
+SwFrameFormat* SwTableBox::ClaimFrameFormat()
+{
+    // This method makes sure that this object is an exclusive SwTableBox client
+    // of an SwTableBoxFormat object
+    // If other SwTableBox objects currently listen to the same SwTableBoxFormat as
+    // this one, something needs to be done
+    SwTableBoxFormat *pRet = static_cast<SwTableBoxFormat*>(GetFrameFormat());
+    SwIterator<SwTableBox,SwFormat> aIter( *pRet );
+    for( SwTableBox* pLast = aIter.First(); pLast; pLast = aIter.Next() )
+    {
+        if ( pLast != this )
+        {
+            // Found another SwTableBox object
+            // create a new Format as a copy and assign me to it
+            // don't copy values and formulas
+            SwTableBoxFormat* pNewFormat = pRet->GetDoc()->MakeTableBoxFormat();
+            pNewFormat->LockModify();
+            *pNewFormat = *pRet;
+            pNewFormat->ResetFormatAttr( RES_BOXATR_FORMULA, RES_BOXATR_VALUE );
+            pNewFormat->UnlockModify();
+
+            // re-register SwCellFrame objects that know me
+            SwIterator<SwCellFrame,SwFormat> aFrameIter( *pRet );
+            for( SwCellFrame* pCell = aFrameIter.First(); pCell; pCell = aFrameIter.Next() )
+                if( pCell->GetTabBox() == this )
+                    pCell->RegisterToFormat( *pNewFormat );
+
+            // re-register myself
+            pNewFormat->Add( this );
+            pRet = pNewFormat;
+            break;
+        }
+    }
+    return pRet;
+}
+
+void SwTableBox::ChgFrameFormat(SwTableBoxFormat* pNewFormat, bool bNeedToReregister)
+{
+    SwFrameFormat* pOld = GetFrameFormat();
+    // tdf#84635 We set bNeedToReregister=false to avoid a quadratic slowdown on loading large tables,
+    // and since we are creating the table for the first time, no re-registration is necessary.
+    // First, re-register the Frames.
+    if(bNeedToReregister)
+        pOld->CallSwClientNotify(sw::TableBoxFormatChanged(*pNewFormat, *this));
+    // Now, re-register self.
+    pNewFormat->Add(this);
+    if(!pOld->HasWriterListeners())
+        delete pOld;
+}
+
+// Return the name of this box. This is determined dynamically
+// resulting from the position in the lines/boxes/tables.
+void sw_GetTableBoxColStr( sal_uInt16 nCol, OUString& rNm )
+{
+    const sal_uInt16 coDiff = 52;   // 'A'-'Z' 'a' - 'z'
+
+    do {
+        const sal_uInt16 nCalc = nCol % coDiff;
+        if( nCalc >= 26 )
+            rNm = OUStringChar( sal_Unicode('a' - 26 + nCalc) ) + rNm;
+        else
+            rNm = OUStringChar( sal_Unicode('A' + nCalc) ) + rNm;
+
+        nCol = nCol - nCalc;
+        if( 0 == nCol )
+            break;
+        nCol /= coDiff;
+        --nCol;
+    } while( true );
+}
+
+Point SwTableBox::GetCoordinates() const
+{
+    if( !m_pStartNode )       // box without content?
+    {
+        // search for the next first box?
+        return Point( 0, 0 );
+    }
+
+    const SwTable& rTable = m_pStartNode->FindTableNode()->GetTable();
+    sal_uInt16 nX, nY;
+    const SwTableBox* pBox = this;
+    do {
+        const SwTableLine* pLine = pBox->GetUpper();
+        // at the first level?
+        const SwTableLines* pLines = pLine->GetUpper()
+                ? &pLine->GetUpper()->GetTabLines() : &rTable.GetTabLines();
+
+        nY = pLines->GetPos( pLine ) + 1 ;
+        nX = pBox->GetUpper()->GetBoxPos( pBox ) + 1;
+        pBox = pLine->GetUpper();
+    } while( pBox );
+    return Point( nX, nY );
+}
+
+OUString SwTableBox::GetName() const
+{
+    if( !m_pStartNode )       // box without content?
+    {
+        // search for the next first box?
+        return OUString();
+    }
+
+    const SwTable& rTable = m_pStartNode->FindTableNode()->GetTable();
+    sal_uInt16 nPos;
+    OUString sNm, sTmp;
+    const SwTableBox* pBox = this;
+    do {
+        const SwTableLine* pLine = pBox->GetUpper();
+        // at the first level?
+        const SwTableLines* pLines = pLine->GetUpper()
+                ? &pLine->GetUpper()->GetTabLines() : &rTable.GetTabLines();
+
+        nPos = pLines->GetPos( pLine ) + 1;
+        sTmp = OUString::number( nPos );
+        if( !sNm.isEmpty() )
+            sNm = sTmp + "." + sNm;
+        else
+            sNm = sTmp;
+
+        nPos = pBox->GetUpper()->GetBoxPos( pBox );
+        sTmp = OUString::number(nPos + 1);
+        pBox = pLine->GetUpper();
+        if( nullptr != pBox )
+            sNm = sTmp + "." + sNm;
+        else
+            sw_GetTableBoxColStr( nPos, sNm );
+
+    } while( pBox );
+    return sNm;
+}
+
+bool SwTableBox::IsInHeadline( const SwTable* pTable ) const
+{
+    if( !GetUpper() )           // should only happen upon merge.
+        return false;
+
+    if( !pTable )
+        pTable = &m_pStartNode->FindTableNode()->GetTable();
+
+    const SwTableLine* pLine = GetUpper();
+    while( pLine->GetUpper() )
+        pLine = pLine->GetUpper()->GetUpper();
+
+    // Headerline?
+    return pTable->GetTabLines()[ 0 ] == pLine;
+}
+
+SwNodeOffset SwTableBox::GetSttIdx() const
+{
+    return m_pStartNode ? m_pStartNode->GetIndex() : SwNodeOffset(0);
+}
+
+bool SwTableBox::IsEmpty() const
+{
+    const SwStartNode *pSttNd = GetSttNd();
+    if( pSttNd &&
+        pSttNd->GetIndex() + 2 == pSttNd->EndOfSectionIndex() )
+    {
+        const SwContentNode *pCNd =
+            pSttNd->GetNodes()[pSttNd->GetIndex()+1]->GetContentNode();
+        if( pCNd && !pCNd->Len() )
+            return true;
+    }
+
+    return false;
+}
+
+    // retrieve information from the client
+bool SwTable::GetInfo( SfxPoolItem& rInfo ) const
+{
+    switch( rInfo.Which() )
+    {
+        case RES_AUTOFMT_DOCNODE:
+        {
+            const SwTableNode* pNode = GetTableNode();
+            if (pNode && &pNode->GetNodes() == static_cast<SwAutoFormatGetDocNode&>(rInfo).pNodes)
+            {
+                if (!m_TabSortContentBoxes.empty())
+                {
+                    SwNodeIndex aIdx( *m_TabSortContentBoxes[0]->GetSttNd() );
+                    GetFrameFormat()->GetDoc()->GetNodes().GoNext( &aIdx );
+                }
+                return false;
+            }
+            break;
+        }
+        case RES_FINDNEARESTNODE:
+            if( GetFrameFormat() &&
+                GetFrameFormat()->GetFormatAttr( RES_PAGEDESC ).GetPageDesc() &&
+                !m_TabSortContentBoxes.empty() &&
+                m_TabSortContentBoxes[0]->GetSttNd()->GetNodes().IsDocNodes() )
+                static_cast<SwFindNearestNode&>(rInfo).CheckNode( *
+                    m_TabSortContentBoxes[0]->GetSttNd()->FindTableNode() );
+            break;
+
+        case RES_CONTENT_VISIBLE:
+            static_cast<SwPtrMsgPoolItem&>(rInfo).pObject = SwIterator<SwFrame,SwFormat>( *GetFrameFormat() ).First();
+            return false;
+    }
+    return true;
+}
+
+SwTable * SwTable::FindTable( SwFrameFormat const*const pFormat )
+{
+    return pFormat
+        ? SwIterator<SwTable,SwFormat>(*pFormat).First()
+        : nullptr;
+}
+
+SwTableNode* SwTable::GetTableNode() const
+{
+    return !GetTabSortBoxes().empty() ?
+           const_cast<SwTableNode*>(GetTabSortBoxes()[ 0 ]->GetSttNd()->FindTableNode()) :
+           m_pTableNode;
+}
+
+void SwTable::SetRefObject( SwServerObject* pObj )
+{
+    if( m_xRefObj.is() )
+        m_xRefObj->Closed();
+
+    m_xRefObj = pObj;
+}
+
+void SwTable::SetHTMLTableLayout(std::shared_ptr<SwHTMLTableLayout> const& r)
+{
+    m_xHTMLLayout = r;
+}
+
+static void ChgTextToNum( SwTableBox& rBox, const OUString& rText, const Color* pCol,
+                    bool bChgAlign )
+{
+    SwNodeOffset nNdPos = rBox.IsValidNumTextNd();
+    ChgTextToNum( rBox,rText,pCol,bChgAlign,nNdPos);
+}
+void ChgTextToNum( SwTableBox& rBox, const OUString& rText, const Color* pCol,
+                    bool bChgAlign, SwNodeOffset nNdPos )
+{
+
+    if( NODE_OFFSET_MAX == nNdPos )
+        return;
+
+    SwDoc* pDoc = rBox.GetFrameFormat()->GetDoc();
+    SwTextNode* pTNd = pDoc->GetNodes()[ nNdPos ]->GetTextNode();
+
+    // assign adjustment
+    if( bChgAlign )
+    {
+        const SfxPoolItem* pItem;
+        pItem = &pTNd->SwContentNode::GetAttr( RES_PARATR_ADJUST );
+        SvxAdjust eAdjust = static_cast<const SvxAdjustItem*>(pItem)->GetAdjust();
+        if( SvxAdjust::Left == eAdjust || SvxAdjust::Block == eAdjust )
+        {
+            SvxAdjustItem aAdjust( *static_cast<const SvxAdjustItem*>(pItem) );
+            aAdjust.SetAdjust( SvxAdjust::Right );
+            pTNd->SetAttr( aAdjust );
+        }
+    }
+
+    // assign color or save "user color"
+    const SvxColorItem* pColorItem = nullptr;
+    if( pTNd->GetpSwAttrSet() )
+        pColorItem = pTNd->GetpSwAttrSet()->GetItemIfSet( RES_CHRATR_COLOR, false );
+
+    const std::optional<Color>& pOldNumFormatColor = rBox.GetSaveNumFormatColor();
+    std::optional<Color> pNewUserColor;
+    if (pColorItem)
+        pNewUserColor = pColorItem->GetValue();
+
+    if( ( pNewUserColor && pOldNumFormatColor &&
+            *pNewUserColor == *pOldNumFormatColor ) ||
+        ( !pNewUserColor && !pOldNumFormatColor ))
+    {
+        // Keep the user color, set updated values, delete old NumFormatColor if needed
+        if( pCol )
+            // if needed, set the color
+            pTNd->SetAttr( SvxColorItem( *pCol, RES_CHRATR_COLOR ));
+        else if( pColorItem )
+        {
+            pNewUserColor = rBox.GetSaveUserColor();
+            if( pNewUserColor )
+                pTNd->SetAttr( SvxColorItem( *pNewUserColor, RES_CHRATR_COLOR ));
+            else
+                pTNd->ResetAttr( RES_CHRATR_COLOR );
+        }
+    }
+    else
+    {
+        // Save user color, set NumFormat color if needed, but never reset the color
+        rBox.SetSaveUserColor( pNewUserColor ? *pNewUserColor : std::optional<Color>() );
+
+        if( pCol )
+            // if needed, set the color
+            pTNd->SetAttr( SvxColorItem( *pCol, RES_CHRATR_COLOR ));
+
+    }
+    rBox.SetSaveNumFormatColor( pCol ? *pCol : std::optional<Color>() );
+
+    if( pTNd->GetText() != rText )
+    {
+        // Exchange text. Bugfix to keep Tabs (front and back!) and annotations (inword comment anchors)
+        const OUString& rOrig = pTNd->GetText();
+        sal_Int32 n;
+
+        for( n = 0; n < rOrig.getLength() && ('\x9' == rOrig[n] || CH_TXTATR_INWORD == rOrig[n]); ++n )
+            ;
+        for( ; n < rOrig.getLength() && '\x01' == rOrig[n]; ++n )
+            ;
+        SwIndex aIdx( pTNd, n );
+        for( n = rOrig.getLength(); n && ('\x9' == rOrig[--n] || CH_TXTATR_INWORD == rOrig[n]); )
+            ;
+        sal_Int32 nEndPos = n;
+        n -= aIdx.GetIndex() - 1;
+
+        // Reset DontExpand-Flags before exchange, to retrigger expansion
+        {
+            SwIndex aResetIdx( aIdx, n );
+            pTNd->DontExpandFormat( aResetIdx, false, false );
+        }
+
+        if( !pDoc->getIDocumentRedlineAccess().IsIgnoreRedline() && !pDoc->getIDocumentRedlineAccess().GetRedlineTable().empty() )
+        {
+            SwPaM aTemp(*pTNd, 0, *pTNd, rOrig.getLength());
+            pDoc->getIDocumentRedlineAccess().DeleteRedline(aTemp, true, RedlineType::Any);
+        }
+
+        // preserve comments inside of the number by deleting number portions starting from the back
+        sal_Int32 nCommentPos = pTNd->GetText().lastIndexOf( CH_TXTATR_INWORD, nEndPos );
+        while( nCommentPos > aIdx.GetIndex() )
+        {
+            pTNd->EraseText( SwIndex(pTNd, nCommentPos+1), nEndPos - nCommentPos, SwInsertFlags::EMPTYEXPAND );
+            // find the next non-sequential comment anchor
+            do
+            {
+                nEndPos = nCommentPos;
+                n = nEndPos - aIdx.GetIndex();
+                nCommentPos = pTNd->GetText().lastIndexOf( CH_TXTATR_INWORD, nEndPos );
+                --nEndPos;
+            }
+            while( nCommentPos > aIdx.GetIndex() && nCommentPos == nEndPos );
+        }
+
+        pTNd->EraseText( aIdx, n, SwInsertFlags::EMPTYEXPAND );
+        pTNd->InsertText( rText, aIdx, SwInsertFlags::EMPTYEXPAND );
+
+        if( pDoc->getIDocumentRedlineAccess().IsRedlineOn() )
+        {
+            SwPaM aTemp(*pTNd, 0, *pTNd, rText.getLength());
+            pDoc->getIDocumentRedlineAccess().AppendRedline(new SwRangeRedline(RedlineType::Insert, aTemp), true);
+        }
+    }
+
+    // assign vertical orientation
+    const SwFormatVertOrient* pVertOrientItem;
+    if( bChgAlign &&
+        ( !(pVertOrientItem = rBox.GetFrameFormat()->GetItemIfSet( RES_VERT_ORIENT )) ||
+            text::VertOrientation::TOP == pVertOrientItem->GetVertOrient() ))
+    {
+        rBox.GetFrameFormat()->SetFormatAttr( SwFormatVertOrient( 0, text::VertOrientation::BOTTOM ));
+    }
+
+}
+
+static void ChgNumToText( SwTableBox& rBox, sal_uLong nFormat )
+{
+    SwNodeOffset nNdPos = rBox.IsValidNumTextNd( false );
+    if( NODE_OFFSET_MAX == nNdPos )
+        return;
+
+    SwDoc* pDoc = rBox.GetFrameFormat()->GetDoc();
+    SwTextNode* pTNd = pDoc->GetNodes()[ nNdPos ]->GetTextNode();
+    bool bChgAlign = pDoc->IsInsTableAlignNum();
+
+    const Color * pCol = nullptr;
+    if( getSwDefaultTextFormat() != nFormat )
+    {
+        // special text format:
+        OUString sTmp;
+        const OUString sText( pTNd->GetText() );
+        pDoc->GetNumberFormatter()->GetOutputString( sText, nFormat, sTmp, &pCol );
+        if( sText != sTmp )
+        {
+            // exchange text
+            SwIndex aIdx( pTNd, sText.getLength() );
+            // Reset DontExpand-Flags before exchange, to retrigger expansion
+            pTNd->DontExpandFormat( aIdx, false, false );
+            aIdx = 0;
+            pTNd->EraseText( aIdx, SAL_MAX_INT32, SwInsertFlags::EMPTYEXPAND );
+            pTNd->InsertText( sTmp, aIdx, SwInsertFlags::EMPTYEXPAND );
+        }
+    }
+
+    const SfxItemSet* pAttrSet = pTNd->GetpSwAttrSet();
+
+    // assign adjustment
+    const SvxAdjustItem* pAdjustItem;
+    if( bChgAlign && pAttrSet &&
+        (pAdjustItem = pAttrSet->GetItemIfSet( RES_PARATR_ADJUST, false )) &&
+        SvxAdjust::Right == pAdjustItem->GetAdjust() )
+    {
+        pTNd->SetAttr( SvxAdjustItem( SvxAdjust::Left, RES_PARATR_ADJUST ) );
+    }
+
+    // assign color or save "user color"
+    const SvxColorItem* pColorItem = nullptr;
+    if( pAttrSet )
+        pColorItem = pAttrSet->GetItemIfSet( RES_CHRATR_COLOR, false );
+
+    const std::optional<Color>& pOldNumFormatColor = rBox.GetSaveNumFormatColor();
+    std::optional<Color> pNewUserColor;
+    if (pColorItem)
+        pNewUserColor = pColorItem->GetValue();
+
+    if( ( pNewUserColor && pOldNumFormatColor &&
+            *pNewUserColor == *pOldNumFormatColor ) ||
+        ( !pNewUserColor && !pOldNumFormatColor ))
+    {
+        // Keep the user color, set updated values, delete old NumFormatColor if needed
+        if( pCol )
+            // if needed, set the color
+            pTNd->SetAttr( SvxColorItem( *pCol, RES_CHRATR_COLOR ));
+        else if( pColorItem )
+        {
+            pNewUserColor = rBox.GetSaveUserColor();
+            if( pNewUserColor )
+                pTNd->SetAttr( SvxColorItem( *pNewUserColor, RES_CHRATR_COLOR ));
+            else
+                pTNd->ResetAttr( RES_CHRATR_COLOR );
+        }
+    }
+    else
+    {
+        // Save user color, set NumFormat color if needed, but never reset the color
+        rBox.SetSaveUserColor( pNewUserColor );
+
+        if( pCol )
+            // if needed, set the color
+            pTNd->SetAttr( SvxColorItem( *pCol, RES_CHRATR_COLOR ));
+
+    }
+    rBox.SetSaveNumFormatColor( pCol ? *pCol : std::optional<Color>() );
+
+    // assign vertical orientation
+    const SwFormatVertOrient* pVertOrientItem;
+    if( bChgAlign &&
+        (pVertOrientItem = rBox.GetFrameFormat()->GetItemIfSet( RES_VERT_ORIENT, false )) &&
+        text::VertOrientation::BOTTOM == pVertOrientItem->GetVertOrient() )
+    {
+        rBox.GetFrameFormat()->SetFormatAttr( SwFormatVertOrient( 0, text::VertOrientation::TOP ));
+    }
+
+}
+void SwTableBoxFormat::BoxAttributeChanged(SwTableBox& rBox, const SwTableBoxNumFormat* pNewFormat, const SwTableBoxFormula* pNewFormula, const SwTableBoxValue* pNewValue, sal_uLong nOldFormat)
+{
+    sal_uLong nNewFormat;
+    if(pNewFormat)
+    {
+        nNewFormat = pNewFormat->GetValue();
+        // new formatting
+        // is it newer or has the current been removed?
+        if( SfxItemState::SET != GetItemState(RES_BOXATR_VALUE, false))
+            pNewFormat = nullptr;
+    }
+    else
+    {
+        // fetch the current Item
+        pNewFormat = GetItemIfSet(RES_BOXATR_FORMAT, false);
+        nOldFormat = GetTableBoxNumFormat().GetValue();
+        nNewFormat = pNewFormat ? pNewFormat->GetValue() : nOldFormat;
+    }
+
+    // is it newer or has the current been removed?
+    if(pNewValue)
+    {
+        if(GetDoc()->GetNumberFormatter()->IsTextFormat(nNewFormat))
+            nOldFormat = 0;
+        else
+        {
+            if(SfxItemState::SET == GetItemState(RES_BOXATR_VALUE, false))
+                nOldFormat = getSwDefaultTextFormat();
+            else
+                nNewFormat = getSwDefaultTextFormat();
+        }
+    }
+
+    // Logic:
+    // Value change: -> "simulate" a format change!
+    // Format change:
+    // Text -> !Text or format change:
+    //          - align right for horizontal alignment, if LEFT or JUSTIFIED
+    //          - align bottom for vertical alignment, if TOP is set, or default
+    //          - replace text (color? negative numbers RED?)
+    // !Text -> Text:
+    //          - align left for horizontal alignment, if RIGHT
+    //          - align top for vertical alignment, if BOTTOM is set
+    SvNumberFormatter* pNumFormatr = GetDoc()->GetNumberFormatter();
+    bool bNewIsTextFormat = pNumFormatr->IsTextFormat(nNewFormat);
+
+    if((!bNewIsTextFormat && nOldFormat != nNewFormat) || pNewFormula)
+    {
+        bool bIsNumFormat = false;
+        OUString aOrigText;
+        bool bChgText = true;
+        double fVal = 0;
+        if(!pNewValue)
+            pNewValue = GetItemIfSet(RES_BOXATR_VALUE, false);
+        if(!pNewValue)
+        {
+            // so far, no value has been set, so try to evaluate the content
+            SwNodeOffset nNdPos = rBox.IsValidNumTextNd();
+            if(NODE_OFFSET_MAX != nNdPos)
+            {
+                sal_uInt32 nTmpFormatIdx = nNewFormat;
+                OUString aText(GetDoc()->GetNodes()[nNdPos] ->GetTextNode()->GetRedlineText());
+                aOrigText = aText;
+                if(aText.isEmpty())
+                    bChgText = false;
+                else
+                {
+                    // Keep Tabs
+                    lcl_TabToBlankAtSttEnd(aText);
+
+                    // JP 22.04.98: Bug 49659 -
+                    //  Special casing for percent
+                    if(SvNumFormatType::PERCENT == pNumFormatr->GetType(nNewFormat))
+                    {
+                        sal_uInt32 nTmpFormat = 0;
+                        if(GetDoc()->IsNumberFormat(aText, nTmpFormat, fVal))
+                        {
+                            if(SvNumFormatType::NUMBER == pNumFormatr->GetType( nTmpFormat))
+                                aText += "%";
+
+                            bIsNumFormat = GetDoc()->IsNumberFormat(aText, nTmpFormatIdx, fVal);
+                        }
+                    }
+                    else
+                        bIsNumFormat = GetDoc()->IsNumberFormat(aText, nTmpFormatIdx, fVal);
+
+                    if(bIsNumFormat)
+                    {
+                        // directly assign value - without Modify
+                        bool bIsLockMod = IsModifyLocked();
+                        LockModify();
+                        SetFormatAttr(SwTableBoxValue(fVal));
+                        if(!bIsLockMod)
+                            UnlockModify();
+                    }
+                }
+            }
+        }
+        else
+        {
+            fVal = pNewValue->GetValue();
+            bIsNumFormat = true;
+        }
+
+        // format contents with the new value assigned and write to paragraph
+        const Color* pCol = nullptr;
+        OUString sNewText;
+        bool bChangeFormat = true;
+        if(DBL_MAX == fVal)
+        {
+            sNewText = SwViewShell::GetShellRes()->aCalc_Error;
+        }
+        else
+        {
+            if(bIsNumFormat)
+                pNumFormatr->GetOutputString(fVal, nNewFormat, sNewText, &pCol);
+            else
+            {
+                // Original text could not be parsed as
+                // number/date/time/..., so keep the text.
+#if 0
+                // Actually the text should be formatted
+                // according to the format, which may include
+                // additional text from the format, for example
+                // in {0;-0;"BAD: "@}. But other places when
+                // entering a new value or changing text or
+                // changing to a different format of type Text
+                // don't do this (yet?).
+                pNumFormatr->GetOutputString(aOrigText, nNewFormat, sNewText, &pCol);
+#else
+                sNewText = aOrigText;
+#endif
+                // Remove the newly assigned numbering format as well if text actually exists.
+                // Exception: assume user-defined formats are always intentional.
+                if (bChgText && pNumFormatr->IsTextFormat(nOldFormat)
+                    && !pNumFormatr->IsUserDefined(nNewFormat))
+                {
+                    rBox.GetFrameFormat()->ResetFormatAttr(RES_BOXATR_FORMAT);
+                    bChangeFormat = false;
+                }
+            }
+
+            if(!bChgText)
+                sNewText.clear();
+        }
+
+        // across all boxes
+        if (bChangeFormat)
+            ChgTextToNum(rBox, sNewText, pCol, GetDoc()->IsInsTableAlignNum());
+
+    }
+    else if(bNewIsTextFormat && nOldFormat != nNewFormat)
+        ChgNumToText(rBox, nNewFormat);
+}
+
+SwTableBox* SwTableBoxFormat::SwTableBoxFormat::GetTableBox()
+{
+    SwIterator<SwTableBox,SwFormat> aIter(*this);
+    auto pBox = aIter.First();
+    SAL_INFO_IF(!pBox, "sw.core", "no box found at format");
+    SAL_WARN_IF(pBox && aIter.Next(), "sw.core", "more than one box found at format");
+    return pBox;
+}
+
+// for detection of modifications (mainly TableBoxAttribute)
+void SwTableBoxFormat::SwClientNotify(const SwModify& rMod, const SfxHint& rHint)
+{
+    if(rHint.GetId() != SfxHintId::SwLegacyModify)
+        return;
+    auto pLegacy = static_cast<const sw::LegacyModifyHint*>(&rHint);
+    if(IsModifyLocked() || !GetDoc() || GetDoc()->IsInDtor())
+    {
+        SwFrameFormat::SwClientNotify(rMod, rHint);
+        return;
+    }
+    const SwTableBoxNumFormat* pNewFormat = nullptr;
+    const SwTableBoxFormula* pNewFormula = nullptr;
+    const SwTableBoxValue* pNewVal = nullptr;
+    sal_uLong nOldFormat = getSwDefaultTextFormat();
+
+    switch(pLegacy->m_pNew ? pLegacy->m_pNew->Which() : 0)
+    {
+        case RES_ATTRSET_CHG:
+        {
+            const SfxItemSet& rSet = *static_cast<const SwAttrSetChg*>(pLegacy->m_pNew)->GetChgSet();
+            pNewFormat = rSet.GetItemIfSet( RES_BOXATR_FORMAT, false);
+            if(pNewFormat)
+                nOldFormat = static_cast<const SwAttrSetChg*>(pLegacy->m_pOld)->GetChgSet()->Get(RES_BOXATR_FORMAT).GetValue();
+            pNewFormula = rSet.GetItemIfSet(RES_BOXATR_FORMULA, false);
+            pNewVal = rSet.GetItemIfSet(RES_BOXATR_VALUE, false);
+            break;
+        }
+        case RES_BOXATR_FORMAT:
+            pNewFormat = static_cast<const SwTableBoxNumFormat*>(pLegacy->m_pNew);
+            nOldFormat = static_cast<const SwTableBoxNumFormat*>(pLegacy->m_pOld)->GetValue();
+            break;
+        case RES_BOXATR_FORMULA:
+            pNewFormula = static_cast<const SwTableBoxFormula*>(pLegacy->m_pNew);
+            break;
+        case RES_BOXATR_VALUE:
+            pNewVal = static_cast<const SwTableBoxValue*>(pLegacy->m_pNew);
+            break;
+    }
+
+    // something changed and some BoxAttribut remained in the set!
+    if( pNewFormat || pNewFormula || pNewVal )
+    {
+        GetDoc()->getIDocumentFieldsAccess().SetFieldsDirty(true, nullptr, SwNodeOffset(0));
+
+        if(SfxItemState::SET == GetItemState(RES_BOXATR_FORMAT, false) ||
+           SfxItemState::SET == GetItemState(RES_BOXATR_VALUE, false) ||
+           SfxItemState::SET == GetItemState(RES_BOXATR_FORMULA, false) )
+        {
+            if(auto pBox = GetTableBox())
+                BoxAttributeChanged(*pBox, pNewFormat, pNewFormula, pNewVal, nOldFormat);
+        }
+    }
+    // call base class
+    SwFrameFormat::SwClientNotify(rMod, rHint);
+}
+
+bool SwTableBoxFormat::supportsFullDrawingLayerFillAttributeSet() const
+{
+    return false;
+}
+
+bool SwTableFormat::supportsFullDrawingLayerFillAttributeSet() const
+{
+    return false;
+}
+
+bool SwTableLineFormat::supportsFullDrawingLayerFillAttributeSet() const
+{
+    return false;
+}
+
+bool SwTableBox::HasNumContent( double& rNum, sal_uInt32& rFormatIndex,
+                            bool& rIsEmptyTextNd ) const
+{
+    bool bRet = false;
+    SwNodeOffset nNdPos = IsValidNumTextNd();
+    if( NODE_OFFSET_MAX != nNdPos )
+    {
+        OUString aText( m_pStartNode->GetNodes()[ nNdPos ]->GetTextNode()->GetRedlineText() );
+        // Keep Tabs
+        lcl_TabToBlankAtSttEnd( aText );
+        rIsEmptyTextNd = aText.isEmpty();
+        SvNumberFormatter* pNumFormatr = GetFrameFormat()->GetDoc()->GetNumberFormatter();
+
+        if( const SwTableBoxNumFormat* pItem = GetFrameFormat()->GetItemIfSet( RES_BOXATR_FORMAT, false) )
+        {
+            rFormatIndex = pItem->GetValue();
+            // Special casing for percent
+            if( !rIsEmptyTextNd && SvNumFormatType::PERCENT == pNumFormatr->GetType( rFormatIndex ))
+            {
+                sal_uInt32 nTmpFormat = 0;
+                if( GetFrameFormat()->GetDoc()->IsNumberFormat( aText, nTmpFormat, rNum ) &&
+                    SvNumFormatType::NUMBER == pNumFormatr->GetType( nTmpFormat ))
+                    aText += "%";
+            }
+        }
+        else
+            rFormatIndex = 0;
+
+        bRet = GetFrameFormat()->GetDoc()->IsNumberFormat( aText, rFormatIndex, rNum );
+    }
+    else
+        rIsEmptyTextNd = false;
+    return bRet;
+}
+
+bool SwTableBox::IsNumberChanged() const
+{
+    bool bRet = true;
+
+    if( SfxItemState::SET == GetFrameFormat()->GetItemState( RES_BOXATR_FORMULA, false ))
+    {
+        const SwTableBoxNumFormat *pNumFormat = GetFrameFormat()->GetItemIfSet( RES_BOXATR_FORMAT, false );
+        const SwTableBoxValue *pValue = GetFrameFormat()->GetItemIfSet( RES_BOXATR_VALUE, false );
+
+        SwNodeOffset nNdPos;
+        if( pNumFormat && pValue && NODE_OFFSET_MAX != ( nNdPos = IsValidNumTextNd() ) )
+        {
+            OUString sNewText, sOldText( m_pStartNode->GetNodes()[ nNdPos ]->
+                                    GetTextNode()->GetRedlineText() );
+            lcl_DelTabsAtSttEnd( sOldText );
+
+            const Color* pCol = nullptr;
+            GetFrameFormat()->GetDoc()->GetNumberFormatter()->GetOutputString(
+                pValue->GetValue(), pNumFormat->GetValue(), sNewText, &pCol );
+
+            bRet = sNewText != sOldText ||
+                    !( ( !pCol && !GetSaveNumFormatColor() ) ||
+                       ( pCol && GetSaveNumFormatColor() &&
+                        *pCol == *GetSaveNumFormatColor() ));
+        }
+    }
+    return bRet;
+}
+
+SwNodeOffset SwTableBox::IsValidNumTextNd( bool bCheckAttr ) const
+{
+    SwNodeOffset nPos = NODE_OFFSET_MAX;
+    if( m_pStartNode )
+    {
+        SwNodeIndex aIdx( *m_pStartNode );
+        SwNodeOffset nIndex = aIdx.GetIndex();
+        const SwNodeOffset nIndexEnd = m_pStartNode->GetNodes()[ nIndex ]->EndOfSectionIndex();
+        const SwTextNode *pTextNode = nullptr;
+        while( ++nIndex < nIndexEnd )
+        {
+            const SwNode* pNode = m_pStartNode->GetNodes()[nIndex];
+            if( pNode->IsTableNode() )
+            {
+                pTextNode = nullptr;
+                break;
+            }
+            if( pNode->IsTextNode() )
+            {
+                if( pTextNode )
+                {
+                    pTextNode = nullptr;
+                    break;
+                }
+                else
+                {
+                    pTextNode = pNode->GetTextNode();
+                    nPos = nIndex;
+                }
+            }
+        }
+        if( pTextNode )
+        {
+            if( bCheckAttr )
+            {
+                const SwpHints* pHts = pTextNode->GetpSwpHints();
+                // do some tests if there's only text in the node!
+                // Flys/fields/...
+                if( pHts )
+                {
+                    sal_Int32 nNextSetField = 0;
+                    for( size_t n = 0; n < pHts->Count(); ++n )
+                    {
+                        const SwTextAttr* pAttr = pHts->Get(n);
+                        if( RES_TXTATR_NOEND_BEGIN <= pAttr->Which() )
+                        {
+                            if ( (pAttr->GetStart() == nNextSetField)
+                                 && (pAttr->Which() == RES_TXTATR_FIELD))
+                            {
+                                // #i104949# hideous hack for report builder:
+                                // it inserts hidden variable-set fields at
+                                // the beginning of para in cell, but they
+                                // should not turn cell into text cell
+                                const SwField* pField = pAttr->GetFormatField().GetField();
+                                if (pField &&
+                                    (pField->GetTypeId() == SwFieldTypesEnum::Set) &&
+                                    (0 != (static_cast<SwSetExpField const*>
+                                           (pField)->GetSubType() &
+                                        nsSwExtendedSubType::SUB_INVISIBLE)))
+                                {
+                                    nNextSetField = pAttr->GetStart() + 1;
+                                    continue;
+                                }
+                            }
+                            else if( RES_TXTATR_ANNOTATION == pAttr->Which() ||
+                                     RES_TXTATR_FTN == pAttr->Which() )
+                            {
+                                continue;
+                            }
+                            nPos = NODE_OFFSET_MAX;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        else
+            nPos = NODE_OFFSET_MAX;
+    }
+    return nPos;
+}
+
+// is this a Formula box or one with numeric content (AutoSum)
+sal_uInt16 SwTableBox::IsFormulaOrValueBox() const
+{
+    sal_uInt16 nWhich = 0;
+    const SwTextNode* pTNd;
+    SwFrameFormat* pFormat = GetFrameFormat();
+    if( SfxItemState::SET == pFormat->GetItemState( RES_BOXATR_FORMULA, false ))
+        nWhich = RES_BOXATR_FORMULA;
+    else if( SfxItemState::SET == pFormat->GetItemState( RES_BOXATR_VALUE, false ) &&
+            !pFormat->GetDoc()->GetNumberFormatter()->IsTextFormat(
+                pFormat->GetTableBoxNumFormat().GetValue() ))
+        nWhich = RES_BOXATR_VALUE;
+    else if( m_pStartNode && m_pStartNode->GetIndex() + 2 == m_pStartNode->EndOfSectionIndex()
+            && nullptr != ( pTNd = m_pStartNode->GetNodes()[ m_pStartNode->GetIndex() + 1 ]
+            ->GetTextNode() ) && pTNd->GetText().isEmpty())
+        nWhich = USHRT_MAX;
+
+    return nWhich;
+}
+
+void SwTableBox::ActualiseValueBox()
+{
+    SwFrameFormat* pFormat = GetFrameFormat();
+    const SwTableBoxNumFormat *pFormatItem = pFormat->GetItemIfSet( RES_BOXATR_FORMAT, true );
+    if (!pFormatItem)
+        return;
+    const SwTableBoxValue *pValItem = pFormat->GetItemIfSet( RES_BOXATR_VALUE );
+    if (!pValItem)
+        return;
+
+    const sal_uLong nFormatId = pFormatItem->GetValue();
+    SwNodeOffset nNdPos = NODE_OFFSET_MAX;
+    SvNumberFormatter* pNumFormatr = pFormat->GetDoc()->GetNumberFormatter();
+
+    if( !pNumFormatr->IsTextFormat( nFormatId ) &&
+        NODE_OFFSET_MAX != (nNdPos = IsValidNumTextNd()) )
+    {
+        double fVal = pValItem->GetValue();
+        const Color* pCol = nullptr;
+        OUString sNewText;
+        pNumFormatr->GetOutputString( fVal, nFormatId, sNewText, &pCol );
+
+        const OUString& rText = m_pStartNode->GetNodes()[ nNdPos ]->GetTextNode()->GetText();
+        if( rText != sNewText )
+            ChgTextToNum( *this, sNewText, pCol, false ,nNdPos);
+    }
+}
+
+struct SwTableCellInfo::Impl
+{
+    const SwTable * m_pTable;
+    const SwCellFrame * m_pCellFrame;
+    const SwTabFrame * m_pTabFrame;
+    typedef o3tl::sorted_vector<const SwTableBox *> TableBoxes_t;
+    TableBoxes_t m_HandledTableBoxes;
+
+public:
+    Impl()
+        : m_pTable(nullptr), m_pCellFrame(nullptr), m_pTabFrame(nullptr)
+    {
+    }
+
+    void setTable(const SwTable * pTable)
+    {
+        m_pTable = pTable;
+        SwFrameFormat * pFrameFormat = m_pTable->GetFrameFormat();
+        m_pTabFrame = SwIterator<SwTabFrame,SwFormat>(*pFrameFormat).First();
+        if (m_pTabFrame && m_pTabFrame->IsFollow())
+            m_pTabFrame = m_pTabFrame->FindMaster(true);
+    }
+
+    const SwCellFrame * getCellFrame() const { return m_pCellFrame; }
+
+    const SwFrame * getNextFrameInTable(const SwFrame * pFrame);
+    const SwCellFrame * getNextCellFrame(const SwFrame * pFrame);
+    const SwCellFrame * getNextTableBoxsCellFrame(const SwFrame * pFrame);
+    bool getNext();
+};
+
+const SwFrame * SwTableCellInfo::Impl::getNextFrameInTable(const SwFrame * pFrame)
+{
+    const SwFrame * pResult = nullptr;
+
+    if (((! pFrame->IsTabFrame()) || pFrame == m_pTabFrame) && pFrame->GetLower())
+        pResult = pFrame->GetLower();
+    else if (pFrame->GetNext())
+        pResult = pFrame->GetNext();
+    else
+    {
+        while (pFrame->GetUpper() != nullptr)
+        {
+            pFrame = pFrame->GetUpper();
+
+            if (pFrame->IsTabFrame())
+            {
+                m_pTabFrame = static_cast<const SwTabFrame *>(pFrame)->GetFollow();
+                pResult = m_pTabFrame;
+                break;
+            }
+            else if (pFrame->GetNext())
+            {
+                pResult = pFrame->GetNext();
+                break;
+            }
+        }
+    }
+
+    return pResult;
+}
+
+const SwCellFrame * SwTableCellInfo::Impl::getNextCellFrame(const SwFrame * pFrame)
+{
+    const SwCellFrame * pResult = nullptr;
+
+    while ((pFrame = getNextFrameInTable(pFrame)) != nullptr)
+    {
+        if (pFrame->IsCellFrame())
+        {
+            pResult = static_cast<const SwCellFrame *>(pFrame);
+            break;
+        }
+    }
+
+    return pResult;
+}
+
+const SwCellFrame * SwTableCellInfo::Impl::getNextTableBoxsCellFrame(const SwFrame * pFrame)
+{
+    const SwCellFrame * pResult = nullptr;
+
+    while ((pFrame = getNextCellFrame(pFrame)) != nullptr)
+    {
+        const SwCellFrame * pCellFrame = static_cast<const SwCellFrame *>(pFrame);
+        const SwTableBox * pTabBox = pCellFrame->GetTabBox();
+        auto aIt = m_HandledTableBoxes.insert(pTabBox);
+        if (aIt.second)
+        {
+            pResult = pCellFrame;
+            break;
+        }
+    }
+
+    return pResult;
+}
+
+const SwCellFrame * SwTableCellInfo::getCellFrame() const
+{
+    return m_pImpl->getCellFrame();
+}
+
+bool SwTableCellInfo::Impl::getNext()
+{
+    if (m_pCellFrame == nullptr)
+    {
+        if (m_pTabFrame != nullptr)
+            m_pCellFrame = Impl::getNextTableBoxsCellFrame(m_pTabFrame);
+    }
+    else
+        m_pCellFrame = Impl::getNextTableBoxsCellFrame(m_pCellFrame);
+
+    return m_pCellFrame != nullptr;
+}
+
+SwTableCellInfo::SwTableCellInfo(const SwTable * pTable)
+    : m_pImpl(std::make_unique<Impl>())
+{
+    m_pImpl->setTable(pTable);
+}
+
+SwTableCellInfo::~SwTableCellInfo()
+{
+}
+
+bool SwTableCellInfo::getNext()
+{
+    return m_pImpl->getNext();
+}
+
+SwRect SwTableCellInfo::getRect() const
+{
+    SwRect aRet;
+
+    if (getCellFrame() != nullptr)
+        aRet = getCellFrame()->getFrameArea();
+
+    return aRet;
+}
+
+const SwTableBox * SwTableCellInfo::getTableBox() const
+{
+    const SwTableBox * pRet = nullptr;
+
+    if (getCellFrame() != nullptr)
+        pRet = getCellFrame()->GetTabBox();
+
+    return pRet;
+}
+
+void SwTable::RegisterToFormat( SwFormat& rFormat )
+{
+    rFormat.Add( this );
+}
+
+bool SwTable::HasLayout() const
+{
+    const SwFrameFormat* pFrameFormat = GetFrameFormat();
+    //a table in a clipboard document doesn't have any layout information
+    return pFrameFormat && SwIterator<SwTabFrame,SwFormat>(*pFrameFormat).First();
+}
+
+void SwTableBox::RegisterToFormat( SwFormat& rFormat )
+{
+    rFormat.Add( this );
+}
+
+// free's any remaining child objects
+SwTableLines::~SwTableLines()
+{
+    for ( const_iterator it = begin(); it != end(); ++it )
+        delete *it;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */