/home/maarten/src/libreoffice/core/sw/source/core/table/swtable.cxx

Bug Summary

File:	home/maarten/src/libreoffice/core/sw/source/core/table/swtable.cxx
Warning:	line 1583, column 38 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name swtable.cxx -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mframe-pointer=all -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -isystem /usr/include/libxml2 -D BOOST_ERROR_CODE_HEADER_ONLY -D BOOST_SYSTEM_NO_DEPRECATED -D CPPU_ENV=gcc3 -D LINUX -D OSL_DEBUG_LEVEL=1 -D SAL_LOG_INFO -D SAL_LOG_WARN -D UNIX -D UNX -D X86_64 -D _PTHREADS -D _REENTRANT -D SW_DLLIMPLEMENTATION -D SWUI_DLL_NAME="libswuilo.so" -D SYSTEM_LIBXML -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/i18n -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/common -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -I /home/maarten/src/libreoffice/core/sw/source/core/inc -I /home/maarten/src/libreoffice/core/sw/source/filter/inc -I /home/maarten/src/libreoffice/core/sw/source/uibase/inc -I /home/maarten/src/libreoffice/core/sw/inc -I /home/maarten/src/libreoffice/core/workdir/SdiTarget/sw/sdi -I /home/maarten/src/libreoffice/core/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include/linux -I /home/maarten/src/libreoffice/core/config_host -I /home/maarten/src/libreoffice/core/workdir/CustomTarget/officecfg/registry -I /home/maarten/src/libreoffice/core/workdir/CustomTarget/sw/generated -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/udkapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/offapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/oovbaapi/normal -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/x86_64-redhat-linux -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O0 -Wno-missing-braces -std=c++17 -fdeprecated-macro -fdebug-compilation-dir /home/maarten/src/libreoffice/core -ferror-limit 19 -fvisibility hidden -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -debug-info-kind=constructor -analyzer-output=html -faddrsig -o /home/maarten/tmp/wis/scan-build-libreoffice/output/report/2020-10-07-141433-9725-1 -x c++ /home/maarten/src/libreoffice/core/sw/source/core/table/swtable.cxx

/home/maarten/src/libreoffice/core/sw/source/core/table/swtable.cxx

→

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* 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 .
*/

20#include <hintids.hxx>
21#include <hints.hxx>
22#include <editeng/lrspitem.hxx>
23#include <editeng/shaditem.hxx>
24#include <editeng/adjustitem.hxx>
25#include <editeng/colritem.hxx>
26#include <sfx2/linkmgr.hxx>
27#include <fmtfsize.hxx>
28#include <fmtornt.hxx>
29#include <fmtpdsc.hxx>
30#include <fldbas.hxx>
31#include <fmtfld.hxx>
32#include <frmatr.hxx>
33#include <doc.hxx>
34#include <IDocumentLinksAdministration.hxx>
35#include <IDocumentRedlineAccess.hxx>
36#include <IDocumentFieldsAccess.hxx>
37#include <docary.hxx>
38#include <frame.hxx>
39#include <swtable.hxx>
40#include <ndtxt.hxx>
41#include <tabcol.hxx>
42#include <tabfrm.hxx>
43#include <cellfrm.hxx>
44#include <rowfrm.hxx>
45#include <swserv.hxx>
46#include <expfld.hxx>
47#include <mdiexp.hxx>
48#include <cellatr.hxx>
49#include <txatbase.hxx>
50#include <htmltbl.hxx>
51#include <swtblfmt.hxx>
52#include <ndindex.hxx>
53#include <tblrwcl.hxx>
54#include <shellres.hxx>
55#include <viewsh.hxx>
56#include <redline.hxx>
57#include <vector>
58#include <calbck.hxx>

60#ifdef DBG_UTIL
61#define CHECK_TABLE(t) (t).CheckConsistency();
62#else
63#define CHECK_TABLE(t)
64#endif

66using namespace com::sun::star;


69#define COLFUZZY20 20

71static void ChgTextToNum( SwTableBox& rBox, const OUString& rText, const Color* pCol,
                  bool bChgAlign, sal_uLong nNdPos );

74inline const Color* SwTableBox::GetSaveUserColor() const
75{
  return mpUserColor.get();
77}

79inline const Color* SwTableBox::GetSaveNumFormatColor() const
80{
  return mpNumFormatColor.get();
82}

84inline void SwTableBox::SetSaveUserColor(const Color* p )
85{
  if (p)
      mpUserColor.reset(new Color(*p));
  else
      mpUserColor.reset();
90}

92inline void SwTableBox::SetSaveNumFormatColor( const Color* p )
93{
  if (p)
      mpNumFormatColor.reset(new Color(*p));
  else
      mpNumFormatColor.reset();
98}

100long SwTableBox::getRowSpan() const
101{
  return mnRowSpan;
103}

105void SwTableBox::setRowSpan( long nNewRowSpan )
106{
  mnRowSpan = nNewRowSpan;
108}

110bool SwTableBox::getDummyFlag() const
111{
  return mbDummyFlag;
113}

115void SwTableBox::setDummyFlag( bool bDummy )
116{
  mbDummyFlag = bDummy;
118}

120//JP 15.09.98: Bug 55741 - Keep tabs (front and rear)
121static OUString& lcl_TabToBlankAtSttEnd( OUString& rText )
122{
  sal_Unicode c;
  sal_Int32 n;

  for( n = 0; n < rText.getLength() && ' ' >= ( c = rText[n] ); ++n )
      if( '\x9' == c )
          rText = rText.replaceAt( n, 1, " " );
  for( n = rText.getLength(); n && ' ' >= ( c = rText[--n] ); )
      if( '\x9' == c )
          rText = rText.replaceAt( n, 1, " " );
  return rText;
133}

135static OUString& lcl_DelTabsAtSttEnd( OUString& rText )
136{
  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;
153}

155void InsTableBox( SwDoc& rDoc, SwTableNode* pTableNd,
                      SwTableLine* pLine, SwTableBoxFormat* pBoxFrameFormat,
                      SwTableBox* pBox,
                      sal_uInt16 nInsPos, sal_uInt16 nCnt )
159{
  OSL_ENSURE( pBox->GetSttNd(), "Box with no start node" )do { if (true && (!(pBox->GetSttNd()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/table/swtable.cxx"
 ":" "160" ": "), "%s", "Box with no start node"); } } while (
false);
  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" )do { if (true && (!(pCNd))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/table/swtable.cxx"
 ":" "165" ": "), "%s", "Box with no content node"); } } while
 (false);

  if( pCNd->IsTextNode() )
  {
      if( pBox->GetSaveNumFormatColor() && pCNd->GetpSwAttrSet() )
      {
          SwAttrSet aAttrSet( *pCNd->GetpSwAttrSet() );
          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 );

  long 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 );
      }
  }
201}

203SwTable::SwTable()
  : SwClient( nullptr ),
  m_pTableNode( nullptr ),
  m_nGraphicsThatResize( 0 ),
  m_nRowsToRepeat( 1 ),
  m_bModifyLocked( false ),
  m_bNewModel( true )
210{
  // default value set in the options
  m_eTableChgMode = GetTableChgDefaultMode();
213}

215SwTable::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 )
224{
225}

227void DelBoxNode( SwTableSortBoxes const & rSortCntBoxes )
228{
  for (size_t n = 0; n < rSortCntBoxes.size(); ++n)
  {
      rSortCntBoxes[ n ]->m_pStartNode = nullptr;
  }
233}

235SwTable::~SwTable()
236{
  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();
259}

261namespace
262{

264template<class T>
265T lcl_MulDiv64(sal_uInt64 nA, sal_uInt64 nM, sal_uInt64 nD)
266{
  return static_cast<T>((nA*nM)/nD);
268}

270}

272static void FormatInArr( std::vector<SwFormat*>& rFormatArr, SwFormat* pBoxFormat )
273{
  std::vector<SwFormat*>::const_iterator it = std::find( rFormatArr.begin(), rFormatArr.end(), pBoxFormat );
  if ( it == rFormatArr.end() )
      rFormatArr.push_back( pBoxFormat );
277}

279static void lcl_ModifyBoxes( SwTableBoxes &rBoxes, const long nOld,
                       const long nNew, std::vector<SwFormat*>& rFormatArr );

282static void lcl_ModifyLines( SwTableLines &rLines, const long nOld,
                       const long nNew, std::vector<SwFormat*>& rFormatArr, const bool bCheckSum )
284{
  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();
      }
  }
298}

300static void lcl_ModifyBoxes( SwTableBoxes &rBoxes, const long nOld,
                       const long nNew, std::vector<SwFormat*>& rFormatArr )
302{
  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 *= nNew;
      nBox /= 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" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/table/swtable.cxx"
 ":" "335" ": "), "%s", "Rounding error"); } } while (false);
      }
      nSum += nBox;
  }
339}

341void SwTable::SwClientNotify(const SwModify&, const SfxHint& rHint)
342{
  auto pLegacy = dynamic_cast<const sw::LegacyModifyHint*>(&rHint);
  if(!pLegacy)
      return;
  // 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
                  && SfxItemState::SET == static_cast<const SwAttrSetChg*>(pLegacy->m_pNew)->GetChgSet()->GetItemState(
                          RES_FRM_SIZE,
                          false,
                          reinterpret_cast<const SfxPoolItem**>(&pNewSize)))
          {
              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());
374}

376void SwTable::AdjustWidths( const long nOld, const long nNew )
377{
  std::vector<SwFormat*> aFormatArr;
  aFormatArr.reserve( m_aLines[0]->GetTabBoxes().size() );
  ::lcl_ModifyLines( m_aLines, nOld, nNew, aFormatArr, true );
381}

383static void lcl_RefreshHidden( SwTabCols &rToFill, size_t nPos )
384{
  for ( size_t i = 0; i < rToFill.Count(); ++i )
  {
      if ( std::abs(static_cast<long>(nPos) - rToFill[i]) <= COLFUZZY20 )
      {
          rToFill.SetHidden( i, false );
          break;
      }
  }
393}

395static void lcl_SortedTabColInsert( SwTabCols &rToFill, const SwTableBox *pBox,
                 const SwFrameFormat *pTabFormat, const bool bHidden,
                 const bool bRefreshHidden )
398{
  const long nWish = pTabFormat->GetFrameSize().GetWidth();
  OSL_ENSURE(nWish, "weird <= 0 width frmfrm")do { if (true && (!(nWish))) { sal_detail_logFormat((
SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/table/swtable.cxx"
 ":" "400" ": "), "%s", "weird <= 0 width frmfrm"); } } while
 (false);

  // The value for the left edge of the box is calculated from the
  // widths of the previous boxes.
  long nPos = 0;
  long nLeftMin = 0;
  long nRightMax = 0;
  if (nWish != 0) //fdo#33012 0 width frmfmt
  {
      SwTwips nSum = 0;
      const SwTableBox  *pCur  = pBox;
      const SwTableLine *pLine = pBox->GetUpper();
      const 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 long nTmp = lcl_MulDiv64<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 )
  {
      long nCmp = rToFill[j];
      if ( (nPos >= ((nCmp >= COLFUZZY20) ? nCmp - COLFUZZY20 : nCmp)) &&
           (nPos <= (nCmp + COLFUZZY20)) )
      {
          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 );
      long nCmp = rToFill[j];

      if ( (nPos >= ((nCmp >= COLFUZZY20) ? nCmp - COLFUZZY20 : nCmp)) &&
           (nPos <= (nCmp + COLFUZZY20)) )
      {
          // check if nLeftMin is > old minimum for entry nPos:
          const long nOldMin = rEntry.nMin;
          if ( nLeftMin > nOldMin )
              rEntry.nMin = nLeftMin;
          // check if nRightMin is < old maximum for entry nPos:
          const long nOldMax = rEntry.nMax;
          if ( nRightMax < nOldMax )
              rEntry.nMax = nRightMax;

          bFoundPos = true;
      }
      else if ( (nRightMax >= ((nCmp >= COLFUZZY20) ? nCmp - COLFUZZY20 : nCmp)) &&
                (nRightMax <= (nCmp + COLFUZZY20)) )
      {
          // check if nPos is > old minimum for entry nRightMax:
          const long nOldMin = rEntry.nMin;
          if ( nPos > nOldMin )
              rEntry.nMin = nPos;

          bFoundMax = true;
      }
  }
502}

504static void lcl_ProcessBoxGet( const SwTableBox *pBox, SwTabCols &rToFill,
                      const SwFrameFormat *pTabFormat, bool bRefreshHidden )
506{
  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 );
519}

521static void lcl_ProcessLineGet( const SwTableLine *pLine, SwTabCols &rToFill,
                       const SwFrameFormat *pTabFormat )
523{
  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 );
  }
533}

535void SwTable::GetTabCols( SwTabCols &rToFill, const SwTableBox *pStart,
            bool bRefreshHidden, bool bCurRowOnly ) const
537{
  // 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();
  }
616}

618// Structure for parameter passing
619struct Parm
620{
  const SwTabCols &rNew;
  const SwTabCols &rOld;
  long nNewWish,
       nOldWish;
  std::deque<SwTableBox*> aBoxArr;
  SwShareBoxFormats aShareFormats;

  Parm( const SwTabCols &rN, const SwTabCols &rO )
      : rNew( rN ), rOld( rO ), nNewWish(0), nOldWish(0)
  {}
631};

633static void lcl_ProcessBoxSet( SwTableBox *pBox, Parm &rParm );

635static void lcl_ProcessLine( SwTableLine *pLine, Parm &rParm )
636{
  SwTableBoxes &rBoxes = pLine->GetTabBoxes();
  for ( size_t i = rBoxes.size(); i > 0; )
  {
      --i;
      ::lcl_ProcessBoxSet( rBoxes[i], rParm );
  }
643}

645static void lcl_ProcessBoxSet( SwTableBox *pBox, Parm &rParm )
646{
  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 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.
      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<long>(
                  rBoxes[i]->GetFrameFormat()->GetFrameSize().GetWidth(),
                  nOldAct, rParm.nOldWish);
          }
          pCur  = pLine->GetUpper();
          pLine = pCur ? pCur->GetUpper() : nullptr;
      }
      long nLeftDiff = 0;
      long nRightDiff = 0;
      if ( nLeft != rParm.rOld.GetLeft() ) // There are still boxes before this.
      {
          // Right edge is left edge plus width.
          const long nWidth = lcl_MulDiv64<long>(
              pBox->GetFrameFormat()->GetFrameSize().GetWidth(),
              nOldAct, rParm.nOldWish);
          const 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] - COLFUZZY20) &&
                   nLeft <= (rParm.rOld[i] + COLFUZZY20) )
              {
                  nLeftPos = i;
                  bFoundLeftPos = true;
              }
              else if ( nRight >= (rParm.rOld[i] - COLFUZZY20) &&
                        nRight <= (rParm.rOld[i] + COLFUZZY20) )
              {
                  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 long nWidth = lcl_MulDiv64<long>(
                  pBox->GetFrameFormat()->GetFrameSize().GetWidth(),
                  nOldAct, rParm.nOldWish);
              const long nTmp = nWidth + rParm.rOld.GetLeft();
              for ( size_t i = 0; i < rParm.rOld.Count(); ++i )
              {
                  if ( nTmp >= (rParm.rOld[i] - COLFUZZY20) &&
                       nTmp <= (rParm.rOld[i] + COLFUZZY20) )
                  {
                      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 < static_cast<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.
          long nTmp = rParm.rNew.GetRight() - rParm.rNew.GetLeft(); // +1 why?
          nLeftDiff *= rParm.nNewWish;
          nLeftDiff /= nTmp;
          nRightDiff *= rParm.nNewWish;
          nRightDiff /= nTmp;
          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;
              }
          }
      }
  }
795}

797static void lcl_ProcessBoxPtr( SwTableBox *pBox, std::deque<SwTableBox*> &rBoxArr,
                         bool bBefore )
799{
  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 );
814}

816static void lcl_AdjustBox( SwTableBox *pBox, const long nDiff, Parm &rParm );

818static void lcl_AdjustLines( SwTableLines &rLines, const long nDiff, Parm &rParm )
819{
  for ( size_t i = 0; i < rLines.size(); ++i )
  {
      SwTableBox *pBox = rLines[i]->GetTabBoxes()
                              [rLines[i]->GetTabBoxes().size()-1];
      lcl_AdjustBox( pBox, nDiff, rParm );
  }
826}

828static void lcl_AdjustBox( SwTableBox *pBox, const long nDiff, Parm &rParm )
829{
  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 );
838}

840void SwTable::SetTabCols( const SwTabCols &rNew, const SwTabCols &rOld,
                        const SwTableBox *pStart, bool bCurRowOnly )
842{
  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.")do { if (true && (!(rOld.Count() == rNew.Count()))) {
 sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/sw/source/core/table/swtable.cxx"
 ":" "853" ": "), "%s", "Number of columns changed."); } } while
 (false);

  // 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
                  aOri.SetHoriOrient( text::HoriOrientation::LEFT_AND_WIDTH );
          }
          pFormat->SetFormatAttr( aOri );
      }
      const long nAct = rOld.GetRight() - rOld.GetLeft(); // +1 why?
      long nTabDiff = 0;

      if ( rOld.GetLeft() != rNew.GetLeft() )
      {
          nTabDiff = rOld.GetLeft() - rNew.GetLeft();
          nTabDiff *= aParm.nOldWish;
          nTabDiff /= nAct;
      }
      if ( rOld.GetRight() != rNew.GetRight() )
      {
          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(32767 *2 +1); // 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 );
          }
      }
  }

986#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 );
      }
  }
995#endif
996}

998typedef std::pair<sal_uInt16, sal_uInt16> ColChange;
999typedef std::list< ColChange > ChangeList;

1001static void lcl_AdjustWidthsInLine( SwTableLine* pLine, ChangeList& rOldNew,
  Parm& rParm, sal_uInt16 nColFuzzy )
1003{
  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 );
      }
  }
1048}

1050static void lcl_CalcNewWidths( std::vector<sal_uInt16> &rSpanPos, ChangeList& rChanges,
  SwTableLine* pLine, long nWish, long nWidth, bool bTop )
1052{
  if( rChanges.empty() )
  {
      rSpanPos.clear();
      return;
  }
  if( rSpanPos.empty() )
  {
      rChanges.clear();
      return;
  }
  std::vector<sal_uInt16> aNewSpanPos;
  ChangeList aNewChanges;
  ChangeList::iterator pCurr = rChanges.begin();
  aNewChanges.push_back( *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 long 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);
1172}

1174void SwTable::NewSetTabCols( Parm &rParm, const SwTabCols &rNew,
  const SwTabCols &rOld, const SwTableBox *pStart, bool bCurRowOnly )
1176{
1177#if OSL_DEBUG_LEVEL1 > 1
  static int nCallCount = 0;
  ++nCallCount;
1180#endif
  // First step: evaluate which lines have been moved/which widths changed
  ChangeList aOldNew;
  const long nNewWidth = rParm.rNew.GetRight() - rParm.rNew.GetLeft();
  const long nOldWidth = rParm.rOld.GetRight() - rParm.rOld.GetLeft();
  if( nNewWidth < 1 || nOldWidth < 1 )
      return;
  for( size_t i = 0; i <= rOld.Count(); ++i )
  {
      long nNewPos;
      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<long>(nNewPos, rParm.nNewWish, nNewWidth);
      nOldPos = lcl_MulDiv64<long>(nOldPos, rParm.nOldWish, nOldWidth);
      if( nOldPos != nNewPos && nNewPos > 0 && nOldPos > 0 )
      {
          ColChange aChg( static_cast<sal_uInt16>(nOldPos), static_cast<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(32767 *2 +1) )
          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 < static_cast<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 < static_cast<sal_uInt16>(rLines.size());
          }
      }
      ::lcl_AdjustWidthsInLine( rLines[nCurr], aOldNew, rParm, COLFUZZY20 );
  }
  else
  {
      for( size_t i = 0; i < rLines.size(); ++i )
          ::lcl_AdjustWidthsInLine( rLines[i], aOldNew, rParm, COLFUZZY20 );
  }
  CHECK_TABLE( *this )
1275}

1277// return the pointer of the box specified.
1278static bool lcl_IsValidRowName( const OUString& rStr )
1279{
  bool bIsValid = true;
  sal_Int32 nLen = rStr.getLength();
  for( sal_Int32 i = 0;  i < nLen && bIsValid; ++i )
  {
      const sal_Unicode cChar = rStr[i];
      if (cChar < '0' || cChar > '9')
          bIsValid = false;
  }
  return bIsValid;
1289}

1291// #i80314#
1292// add 3rd parameter and its handling
1293sal_uInt16 SwTable::GetBoxNum( OUString& rStr, bool bFirstPart,
                          const bool bPerformValidCheck )
1295{
  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((sal_uInt16) 0xFFFF)) {
              overflow = true;
          }
          ++nPos;
      }
      nRet = overflow ? SAL_MAX_UINT16((sal_uInt16) 0xFFFF) : 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 = static_cast<sal_uInt16>(rStr.toInt32());
          }
          rStr.clear();
      }
      else
      {
          nRet = 0;
          const OUString aText( rStr.copy( 0, nPos ) );
          if ( !bPerformValidCheck || lcl_IsValidRowName( aText ) )
          {
              nRet = static_cast<sal_uInt16>(aText.toInt32());
          }
          rStr = rStr.copy( nPos+1 );
      }
  }
  return nRet;
1349}

1351// #i80314#
1352// add 2nd parameter and its handling
1353const SwTableBox* SwTable::GetTableBox( const OUString& rName,
                                    const bool bPerformValidCheck ) const
1355{
  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!" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/table/swtable.cxx"
 ":" "1392" ": "), "%s", "Box without content, looking for the next one!"
); } } while (false);
      // "drop this" until the first box
      while( !pBox->GetTabLines().empty() )
          pBox = pBox->GetTabLines().front()->GetTabBoxes().front();
  }
  return pBox;
1398}

1400SwTableBox* SwTable::GetTableBox( sal_uLong nSttIdx )
1401{
  // 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();
  sal_uLong 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 )
  {
      SwModify* pModify = pCNd;
      // #144862# Better handling of table in table
      if ( pTableNd && pTableNd->GetTable().GetFrameFormat() )
          pModify = pTableNd->GetTable().GetFrameFormat();

      SwFrame* pFrame = pModify ? SwIterator<SwFrame,SwModify>(*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;
1452}

1454bool SwTable::IsTableComplex() const
1455{
  // 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;
1467}

1469SwTableLine::SwTableLine( SwTableLineFormat *pFormat, sal_uInt16 nBoxes,
                          SwTableBox *pUp )
  : SwClient( pFormat ),
  m_aBoxes(),
  m_pUpper( pUp )
1474{
  m_aBoxes.reserve( nBoxes );
1476}

1478SwTableLine::~SwTableLine()
1479{
  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
  SwModify* pMod = GetFrameFormat();
  pMod->Remove( this );               // remove,
  if( !pMod->HasWriterListeners() )
      delete pMod;    // and delete
1489}

1491SwFrameFormat* SwTableLine::ClaimFrameFormat()
1492{
  // 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;
1522}

1524void SwTableLine::ChgFrameFormat( SwTableLineFormat *pNewFormat )
1525{
  SwFrameFormat *pOld = GetFrameFormat();
  SwIterator<SwRowFrame,SwFormat> aIter( *pOld );

  // First, re-register the Frames.
  for( SwRowFrame* pRow = aIter.First(); pRow; pRow = aIter.Next() )
  {
      if( pRow->GetTabLine() == this )
      {
          pRow->RegisterToFormat( *pNewFormat );

          pRow->InvalidateSize();
          pRow->InvalidatePrt_();
          pRow->SetCompletePaint();
          pRow->ReinitializeFrameSizeAttrFlags();

          // #i35063#
          // consider 'split row allowed' attribute
          SwTabFrame* pTab = pRow->FindTabFrame();
          bool bInFollowFlowRow = false;
          const bool bInFirstNonHeadlineRow = pTab->IsFollow() &&
                                              pRow == pTab->GetFirstNonHeadlineRow();
          if ( bInFirstNonHeadlineRow ||
               !pRow->GetNext() ||
               ( bInFollowFlowRow = pRow->IsInFollowFlowRow() ) ||
               nullptr != pRow->IsInSplitTableRow() )
          {
              if ( bInFirstNonHeadlineRow || bInFollowFlowRow )
                  pTab = pTab->FindMaster();

              pTab->SetRemoveFollowFlowLinePending( true );
              pTab->InvalidatePos();
          }
      }
  }

  // Now, re-register self.
  pNewFormat->Add( this );

  if ( !pOld->HasWriterListeners() )
      delete pOld;
1566}

1568SwTwips SwTableLine::GetTableLineHeight( bool& bLayoutAvailable ) const
1569{
  SwTwips nRet = 0;
  bLayoutAvailable = false;
  SwIterator<SwRowFrame,SwFormat> aIter( *GetFrameFormat() );
1
Calling constructor for 'SwIterator<SwRowFrame, SwFormat, sw::IteratorMode::Exact>'→
16
←
Returning from constructor for 'SwIterator<SwRowFrame, SwFormat, sw::IteratorMode::Exact>'→
  // 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() )
17
←
Calling 'SwIterator::First'→
29
←
Returning from 'SwIterator::First'→
30
←
Loop condition is true.  Entering loop body→
  {
      if( pLast->GetTabLine() == this )
31
←
Assuming the condition is true→
32
←
Taking true branch→
      {
          const SwTabFrame* pTab = pLast->FindTabFrame();
33
←
Calling 'SwFrame::FindTabFrame'→
38
←
Returning from 'SwFrame::FindTabFrame'→
39
←
'pTab' initialized here→
          bLayoutAvailable = ( pTab && pTab->IsVertical() ) ?
40
←
Assuming 'pTab' is null→
                             ( 0 < pTab->getFrameArea().Height() ) :
                             ( 0 < pTab->getFrameArea().Width() );
41
←
Called C++ object pointer is null

          // 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;
1605}

1607SwTableBox::SwTableBox( SwTableBoxFormat* pFormat, sal_uInt16 nLines, SwTableLine *pUp )
  : SwClient(nullptr)
  , m_aLines()
  , m_pStartNode(nullptr)
  , m_pUpper(pUp)
  , mnRowSpan(1)
  , mbDummyFlag(false)
  , mbDirectFormatting(false)
1615{
  m_aLines.reserve( nLines );
  CheckBoxFormat( pFormat )->Add( this );
1618}

1620SwTableBox::SwTableBox( SwTableBoxFormat* pFormat, const SwNodeIndex &rIdx,
                      SwTableLine *pUp )
  : SwClient(nullptr)
  , m_aLines()
  , m_pUpper(pUp)
  , mnRowSpan(1)
  , mbDummyFlag(false)
  , mbDirectFormatting(false)
1628{
  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?")(static_cast <bool> (pTableNd && "In which table is that box?"
) ? void (0) : __assert_fail ("pTableNd && \"In which table is that box?\""
, "/home/maarten/src/libreoffice/core/sw/source/core/table/swtable.cxx"
, 1635, __extension__ __PRETTY_FUNCTION__));
  SwTableSortBoxes& rSrtArr = const_cast<SwTableSortBoxes&>(pTableNd->GetTable().
                              GetTabSortBoxes());
  SwTableBox* p = this;   // error: &this
  rSrtArr.insert( p );        // insert
1640}

1642SwTableBox::SwTableBox( SwTableBoxFormat* pFormat, const SwStartNode& rSttNd, SwTableLine *pUp )
  : SwClient(nullptr)
  , m_aLines()
  , m_pStartNode(&rSttNd)
  , m_pUpper(pUp)
  , mnRowSpan(1)
  , mbDummyFlag(false)
  , mbDirectFormatting(false)
1650{
  CheckBoxFormat( pFormat )->Add( this );

  // insert into the table
  const SwTableNode* pTableNd = m_pStartNode->FindTableNode();
  OSL_ENSURE( pTableNd, "In which table is the box?" )do { if (true && (!(pTableNd))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/table/swtable.cxx"
 ":" "1655" ": "), "%s", "In which table is the box?"); } } while
 (false);
  SwTableSortBoxes& rSrtArr = const_cast<SwTableSortBoxes&>(pTableNd->GetTable().
                              GetTabSortBoxes());
  SwTableBox* p = this;   // error: &this
  rSrtArr.insert( p );        // insert
1660}

1662void SwTableBox::RemoveFromTable()
1663{
  if (m_pStartNode) // box containing contents?
  {
      // remove from table
      const SwTableNode* pTableNd = m_pStartNode->FindTableNode();
      assert(pTableNd && "In which table is that box?")(static_cast <bool> (pTableNd && "In which table is that box?"
) ? void (0) : __assert_fail ("pTableNd && \"In which table is that box?\""
, "/home/maarten/src/libreoffice/core/sw/source/core/table/swtable.cxx"
, 1668, __extension__ __PRETTY_FUNCTION__));
      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
  }
1675}

1677SwTableBox::~SwTableBox()
1678{
  if (!GetFrameFormat()->GetDoc()->IsInDtor())
  {
      RemoveFromTable();
  }

  // the TabelleBox can be deleted if it's the last client of the FrameFormat
  SwModify* pMod = GetFrameFormat();
  pMod->Remove( this );               // remove,
  if( !pMod->HasWriterListeners() )
      delete pMod;    // and delete
1689}

1691SwTableBoxFormat* SwTableBox::CheckBoxFormat( SwTableBoxFormat* pFormat )
1692{
  // 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;
1713}

1715SwFrameFormat* SwTableBox::ClaimFrameFormat()
1716{
  // 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;
1749}

1751void SwTableBox::ChgFrameFormat( SwTableBoxFormat* pNewFormat, bool bNeedToReregister )
1752{
  SwFrameFormat *pOld = GetFrameFormat();
  SwIterator<SwCellFrame,SwFormat> aIter( *pOld );

  // 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)
      for( SwCellFrame* pCell = aIter.First(); pCell; pCell = aIter.Next() )
      {
          if( pCell->GetTabBox() == this )
          {
              pCell->RegisterToFormat( *pNewFormat );
              pCell->InvalidateSize();
              pCell->InvalidatePrt_();
              pCell->SetCompletePaint();
              pCell->SetDerivedVert( false );
              pCell->CheckDirChange();

              // #i47489#
              // make sure that the row will be formatted, in order
              // to have the correct Get(Top|Bottom)MarginForLowers values
              // set at the row.
              const SwTabFrame* pTab = pCell->FindTabFrame();
              if ( pTab && pTab->IsCollapsingBorders() )
              {
                  SwFrame* pRow = pCell->GetUpper();
                  pRow->InvalidateSize_();
                  pRow->InvalidatePrt_();
              }
          }
      }

  // Now, re-register self.
  pNewFormat->Add( this );

  if( !pOld->HasWriterListeners() )
      delete pOld;
1791}

1793// Return the name of this box. This is determined dynamically
1794// resulting from the position in the lines/boxes/tables.
1795void sw_GetTableBoxColStr( sal_uInt16 nCol, OUString& rNm )
1796{
  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 );
1812}

1814Point SwTableBox::GetCoordinates() const
1815{
  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 );
1836}

1838OUString SwTableBox::GetName() const
1839{
  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;
1873}

1875bool SwTableBox::IsInHeadline( const SwTable* pTable ) const
1876{
  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;
1889}

1891sal_uLong SwTableBox::GetSttIdx() const
1892{
  return m_pStartNode ? m_pStartNode->GetIndex() : 0;
1894}

  // retrieve information from the client
1897bool SwTable::GetInfo( SfxPoolItem& rInfo ) const
1898{
  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;
1929}

1931SwTable * SwTable::FindTable( SwFrameFormat const*const pFormat )
1932{
  return pFormat
      ? SwIterator<SwTable,SwFormat>(*pFormat).First()
      : nullptr;
1936}

1938SwTableNode* SwTable::GetTableNode() const
1939{
  return !GetTabSortBoxes().empty() ?
         const_cast<SwTableNode*>(GetTabSortBoxes()[ 0 ]->GetSttNd()->FindTableNode()) :
         m_pTableNode;
1943}

1945void SwTable::SetRefObject( SwServerObject* pObj )
1946{
  if( m_xRefObj.is() )
      m_xRefObj->Closed();

  m_xRefObj = pObj;
1951}

1953void SwTable::SetHTMLTableLayout(std::shared_ptr<SwHTMLTableLayout> const& r)
1954{
  m_xHTMLLayout = r;
1956}

1958static void ChgTextToNum( SwTableBox& rBox, const OUString& rText, const Color* pCol,
                  bool bChgAlign )
1960{
  sal_uLong nNdPos = rBox.IsValidNumTextNd();
  ChgTextToNum( rBox,rText,pCol,bChgAlign,nNdPos);
1963}
1964void ChgTextToNum( SwTableBox& rBox, const OUString& rText, const Color* pCol,
                  bool bChgAlign,sal_uLong nNdPos )
1966{

  if( ULONG_MAX(9223372036854775807L *2UL+1UL) == nNdPos )
      return;

  SwDoc* pDoc = rBox.GetFrameFormat()->GetDoc();
  SwTextNode* pTNd = pDoc->GetNodes()[ nNdPos ]->GetTextNode();
  const SfxPoolItem* pItem;

  // assign adjustment
  if( bChgAlign )
  {
      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"
  if( !pTNd->GetpSwAttrSet() || SfxItemState::SET != pTNd->GetpSwAttrSet()->
      GetItemState( RES_CHRATR_COLOR, false, &pItem ))
      pItem = nullptr;

  const Color* pOldNumFormatColor = rBox.GetSaveNumFormatColor();
  const Color* pNewUserColor = pItem ? &static_cast<const SvxColorItem*>(pItem)->GetValue() : nullptr;

  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( pItem )
      {
          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 );

  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_INWORDu'\xFFF9' == 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_INWORDu'\xFFF9' == 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_INWORDu'\xFFF9', 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_INWORDu'\xFFF9', 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
  if( bChgAlign &&
      ( SfxItemState::SET != rBox.GetFrameFormat()->GetItemState(
          RES_VERT_ORIENT, true, &pItem ) ||
          text::VertOrientation::TOP == static_cast<const SwFormatVertOrient*>(pItem)->GetVertOrient() ))
  {
      rBox.GetFrameFormat()->SetFormatAttr( SwFormatVertOrient( 0, text::VertOrientation::BOTTOM ));
  }

2088}

2090static void ChgNumToText( SwTableBox& rBox, sal_uLong nFormat )
2091{
  sal_uLong nNdPos = rBox.IsValidNumTextNd( false );
  if( ULONG_MAX(9223372036854775807L *2UL+1UL) == nNdPos )
      return;

  SwDoc* pDoc = rBox.GetFrameFormat()->GetDoc();
  SwTextNode* pTNd = pDoc->GetNodes()[ nNdPos ]->GetTextNode();
  bool bChgAlign = pDoc->IsInsTableAlignNum();
  const SfxPoolItem* pItem;

  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((sal_Int32) 0x7FFFFFFF), SwInsertFlags::EMPTYEXPAND );
          pTNd->InsertText( sTmp, aIdx, SwInsertFlags::EMPTYEXPAND );
      }
  }

  const SfxItemSet* pAttrSet = pTNd->GetpSwAttrSet();

  // assign adjustment
  if( bChgAlign && pAttrSet && SfxItemState::SET == pAttrSet->GetItemState(
      RES_PARATR_ADJUST, false, &pItem ) &&
          SvxAdjust::Right == static_cast<const SvxAdjustItem*>(pItem)->GetAdjust() )
  {
      pTNd->SetAttr( SvxAdjustItem( SvxAdjust::Left, RES_PARATR_ADJUST ) );
  }

  // assign color or save "user color"
  if( !pAttrSet || SfxItemState::SET != pAttrSet->
      GetItemState( RES_CHRATR_COLOR, false, &pItem ))
      pItem = nullptr;

  const Color* pOldNumFormatColor = rBox.GetSaveNumFormatColor();
  const Color* pNewUserColor = pItem ? &static_cast<const SvxColorItem*>(pItem)->GetValue() : nullptr;

  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( pItem )
      {
          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 );

  // assign vertical orientation
  if( bChgAlign &&
      SfxItemState::SET == rBox.GetFrameFormat()->GetItemState(
      RES_VERT_ORIENT, false, &pItem ) &&
      text::VertOrientation::BOTTOM == static_cast<const SwFormatVertOrient*>(pItem)->GetVertOrient() )
  {
      rBox.GetFrameFormat()->SetFormatAttr( SwFormatVertOrient( 0, text::VertOrientation::TOP ));
  }

2176}

2178// for detection of modifications (mainly TableBoxAttribute)
2179void SwTableBoxFormat::Modify( const SfxPoolItem* pOld, const SfxPoolItem* pNew )
2180{
  if( !IsModifyLocked() && GetDoc() && !GetDoc()->IsInDtor())
  {
      const SwTableBoxNumFormat *pNewFormat = nullptr;
      const SwTableBoxFormula *pNewFormula = nullptr;
      const SwTableBoxValue *pNewVal = nullptr;
      sal_uLong nOldFormat = getSwDefaultTextFormat();

      switch( pNew ? pNew->Which() : 0 )
      {
          case RES_ATTRSET_CHG:
          {
              const SfxItemSet& rSet = *static_cast<const SwAttrSetChg*>(pNew)->GetChgSet();
              if( SfxItemState::SET == rSet.GetItemState( RES_BOXATR_FORMAT,
                                  false, reinterpret_cast<const SfxPoolItem**>(&pNewFormat) ) )
                  nOldFormat = static_cast<const SwAttrSetChg*>(pOld)->
                          GetChgSet()->Get( RES_BOXATR_FORMAT ).GetValue();
              rSet.GetItemState( RES_BOXATR_FORMULA, false,
                                  reinterpret_cast<const SfxPoolItem**>(&pNewFormula) );
              rSet.GetItemState( RES_BOXATR_VALUE, false,
                                  reinterpret_cast<const SfxPoolItem**>(&pNewVal) );
              break;
          }
          case RES_BOXATR_FORMAT:
              pNewFormat = static_cast<const SwTableBoxNumFormat*>(pNew);
              nOldFormat = static_cast<const SwTableBoxNumFormat*>(pOld)->GetValue();
              break;
          case RES_BOXATR_FORMULA:
              pNewFormula = static_cast<const SwTableBoxFormula*>(pNew);
              break;
          case RES_BOXATR_VALUE:
              pNewVal = static_cast<const SwTableBoxValue*>(pNew);
              break;
      }

      // something changed and some BoxAttribut remained in the set!
      if( pNewFormat || pNewFormula || pNewVal )
      {
          GetDoc()->getIDocumentFieldsAccess().SetFieldsDirty(true, nullptr, 0);

          if( SfxItemState::SET == GetItemState( RES_BOXATR_FORMAT, false ) ||
              SfxItemState::SET == GetItemState( RES_BOXATR_VALUE, false ) ||
              SfxItemState::SET == GetItemState( RES_BOXATR_FORMULA, false ) )
          {
              // fetch the box
              SwIterator<SwTableBox,SwFormat> aIter( *this );
              SwTableBox* pBox = aIter.First();
              if( pBox )
              {
                  OSL_ENSURE( !aIter.Next(), "zero or more than one box at format" )do { if (true && (!(!aIter.Next()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/table/swtable.cxx"
 ":" "2229" ": "), "%s", "zero or more than one box at format"
); } } while (false);

                  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
                      (void)GetItemState(RES_BOXATR_FORMAT, false, reinterpret_cast<const SfxPoolItem**>(&pNewFormat));
                      nOldFormat = GetTableBoxNumFormat().GetValue();
                      nNewFormat = pNewFormat ? pNewFormat->GetValue() : nOldFormat;
                  }

                  // is it newer or has the current been removed?
                  if( pNewVal )
                  {
                      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( !pNewVal && SfxItemState::SET != GetItemState(
                          RES_BOXATR_VALUE, false, reinterpret_cast<const SfxPoolItem**>(&pNewVal) ))
                      {
                          // so far, no value has been set, so try to evaluate the content
                          sal_uLong nNdPos = pBox->IsValidNumTextNd();
                          if( ULONG_MAX(9223372036854775807L *2UL+1UL) != 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 = pNewVal->GetValue();
                          bIsNumFormat = true;
                      }

                      // format contents with the new value assigned and write to paragraph
                      const Color* pCol = nullptr;
                      OUString sNewText;
                      if( DBL_MAX1.7976931348623157e+308 == 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.
2353#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 );
2362#else
                              sNewText = aOrigText;
2364#endif
                          }

                          if( !bChgText )
                          {
                              sNewText.clear();
                          }
                      }

                      // across all boxes
                      ChgTextToNum( *pBox, sNewText, pCol,
                                      GetDoc()->IsInsTableAlignNum() );

                  }
                  else if( bNewIsTextFormat && nOldFormat != nNewFormat )
                  {
                      ChgNumToText( *pBox, nNewFormat );
                  }
              }
          }
      }
  }
  // call base class
  SwFrameFormat::Modify( pOld, pNew );
2388}

2390bool SwTableBoxFormat::supportsFullDrawingLayerFillAttributeSet() const
2391{
  return false;
2393}

2395bool SwTableFormat::supportsFullDrawingLayerFillAttributeSet() const
2396{
  return false;
2398}

2400bool SwTableLineFormat::supportsFullDrawingLayerFillAttributeSet() const
2401{
  return false;
2403}

2405bool SwTableBox::HasNumContent( double& rNum, sal_uInt32& rFormatIndex,
                          bool& rIsEmptyTextNd ) const
2407{
  bool bRet = false;
  sal_uLong nNdPos = IsValidNumTextNd();
  if( ULONG_MAX(9223372036854775807L *2UL+1UL) != nNdPos )
  {
      OUString aText( m_pStartNode->GetNodes()[ nNdPos ]->GetTextNode()->GetRedlineText() );
      // Keep Tabs
      lcl_TabToBlankAtSttEnd( aText );
      rIsEmptyTextNd = aText.isEmpty();
      SvNumberFormatter* pNumFormatr = GetFrameFormat()->GetDoc()->GetNumberFormatter();

      const SfxPoolItem* pItem;
      if( SfxItemState::SET == GetFrameFormat()->GetItemState( RES_BOXATR_FORMAT, false, &pItem ))
      {
          rFormatIndex = static_cast<const SwTableBoxNumFormat*>(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;
2439}

2441bool SwTableBox::IsNumberChanged() const
2442{
  bool bRet = true;

  if( SfxItemState::SET == GetFrameFormat()->GetItemState( RES_BOXATR_FORMULA, false ))
  {
      const SwTableBoxNumFormat *pNumFormat;
      const SwTableBoxValue *pValue;

      if( SfxItemState::SET != GetFrameFormat()->GetItemState( RES_BOXATR_VALUE, false,
          reinterpret_cast<const SfxPoolItem**>(&pValue) ))
          pValue = nullptr;
      if( SfxItemState::SET != GetFrameFormat()->GetItemState( RES_BOXATR_FORMAT, false,
          reinterpret_cast<const SfxPoolItem**>(&pNumFormat) ))
          pNumFormat = nullptr;

      sal_uLong nNdPos;
      if( pNumFormat && pValue && ULONG_MAX(9223372036854775807L *2UL+1UL) != ( 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;
2475}

2477sal_uLong SwTableBox::IsValidNumTextNd( bool bCheckAttr ) const
2478{
  sal_uLong nPos = ULONG_MAX(9223372036854775807L *2UL+1UL);
  if( m_pStartNode )
  {
      SwNodeIndex aIdx( *m_pStartNode );
      sal_uLong nIndex = aIdx.GetIndex();
      const sal_uLong 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() )
                          {
                              continue;
                          }
                          nPos = ULONG_MAX(9223372036854775807L *2UL+1UL);
                          break;
                      }
                  }
              }
          }
      }
      else
          nPos = ULONG_MAX(9223372036854775807L *2UL+1UL);
  }
  return nPos;
2556}

2558// is this a Formula box or one with numeric content (AutoSum)
2559sal_uInt16 SwTableBox::IsFormulaOrValueBox() const
2560{
  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(32767 *2 +1);

  return nWhich;
2576}

2578void SwTableBox::ActualiseValueBox()
2579{
  const SfxPoolItem *pFormatItem, *pValItem;
  SwFrameFormat* pFormat = GetFrameFormat();
  if( SfxItemState::SET != pFormat->GetItemState( RES_BOXATR_FORMAT, true, &pFormatItem )
      || SfxItemState::SET != pFormat->GetItemState( RES_BOXATR_VALUE, true, &pValItem ))
      return;

  const sal_uLong nFormatId = static_cast<const SwTableBoxNumFormat*>(pFormatItem)->GetValue();
  sal_uLong nNdPos = ULONG_MAX(9223372036854775807L *2UL+1UL);
  SvNumberFormatter* pNumFormatr = pFormat->GetDoc()->GetNumberFormatter();

  if( !pNumFormatr->IsTextFormat( nFormatId ) &&
      ULONG_MAX(9223372036854775807L *2UL+1UL) != (nNdPos = IsValidNumTextNd()) )
  {
      double fVal = static_cast<const SwTableBoxValue*>(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);
  }
2602}

2604struct SwTableCellInfo::Impl
2605{
  const SwTable * m_pTable;
  const SwCellFrame * m_pCellFrame;
  const SwTabFrame * m_pTabFrame;
  typedef o3tl::sorted_vector<const SwTableBox *> TableBoxes_t;
  TableBoxes_t m_HandledTableBoxes;

2612public:
  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();
2633};

2635const SwFrame * SwTableCellInfo::Impl::getNextFrameInTable(const SwFrame * pFrame)
2636{
  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;
2664}

2666const SwCellFrame * SwTableCellInfo::Impl::getNextCellFrame(const SwFrame * pFrame)
2667{
  const SwCellFrame * pResult = nullptr;

  while ((pFrame = getNextFrameInTable(pFrame)) != nullptr)
  {
      if (pFrame->IsCellFrame())
      {
          pResult = static_cast<const SwCellFrame *>(pFrame);
          break;
      }
  }

  return pResult;
2680}

2682const SwCellFrame * SwTableCellInfo::Impl::getNextTableBoxsCellFrame(const SwFrame * pFrame)
2683{
  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;
2699}

2701const SwCellFrame * SwTableCellInfo::getCellFrame() const
2702{
  return m_pImpl->getCellFrame();
2704}

2706bool SwTableCellInfo::Impl::getNext()
2707{
  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;
2717}

2719SwTableCellInfo::SwTableCellInfo(const SwTable * pTable)
  : m_pImpl(std::make_unique<Impl>())
2721{
  m_pImpl->setTable(pTable);
2723}

2725SwTableCellInfo::~SwTableCellInfo()
2726{
2727}

2729bool SwTableCellInfo::getNext()
2730{
  return m_pImpl->getNext();
2732}

2734SwRect SwTableCellInfo::getRect() const
2735{
  SwRect aRet;

  if (getCellFrame() != nullptr)
      aRet = getCellFrame()->getFrameArea();

  return aRet;
2742}

2744const SwTableBox * SwTableCellInfo::getTableBox() const
2745{
  const SwTableBox * pRet = nullptr;

  if (getCellFrame() != nullptr)
      pRet = getCellFrame()->GetTabBox();

  return pRet;
2752}

2754void SwTable::RegisterToFormat( SwFormat& rFormat )
2755{
  rFormat.Add( this );
2757}

2759bool SwTable::HasLayout() const
2760{
  const SwFrameFormat* pFrameFormat = GetFrameFormat();
  //a table in a clipboard document doesn't have any layout information
  return pFrameFormat && SwIterator<SwTabFrame,SwFormat>(*pFrameFormat).First();
2764}

2766void SwTableLine::RegisterToFormat( SwFormat& rFormat )
2767{
  rFormat.Add( this );
2769}

2771void SwTableBox::RegisterToFormat( SwFormat& rFormat )
2772{
  rFormat.Add( this );
2774}

2776// free's any remaining child objects
2777SwTableLines::~SwTableLines()
2778{
  for ( const_iterator it = begin(); it != end(); ++it )
      delete *it;
2781}

2783/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

←

/home/maarten/src/libreoffice/core/sw/inc/calbck.hxx

→

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* 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 .
*/

20#ifndef INCLUDED_SW_INC_CALBCK_HXX
21#define INCLUDED_SW_INC_CALBCK_HXX

23#include <cassert>

25#include <svl/hint.hxx>
26#include <svl/broadcast.hxx>
27#include <svl/poolitem.hxx>
28#include "swdllapi.h"
29#include "ring.hxx"
30#include <type_traits>
31#include <vector>
32#include <memory>

34class SwModify;
35class SfxPoolItem;

37/*
  SwModify and SwClient cooperate in propagating attribute changes.
  If an attribute changes, the change is notified to all dependent
  formats and other interested objects, e.g. Nodes. The clients will detect
  if the change affects them. It could be that the changed attribute is
  overruled in the receiving object so that its change does not become
  effective or that the receiver is not interested in the particular attribute
  in general (though probably in other attributes of the SwModify object they
  are registered in).
  As SwModify objects are derived from SwClient, they can create a chain of SwClient
  objects where changes can get propagated through.
  Each SwClient can be registered at only one SwModify object, while each SwModify
  object is connected to a list of SwClient objects. If an object derived from SwClient
  wants to get notifications from more than one SwModify object, it must create additional
  SwClient objects. The SwDepend class allows to handle their notifications in the same
  notification callback as it forwards the Modify() calls it receives to a "master"
  SwClient implementation.
  The SwIterator class allows to iterate over the SwClient objects registered at an
  SwModify. For historical reasons its ability to use TypeInfo to restrict this iteration
  to objects of a particular type created a lot of code that misuses SwClient-SwModify
  relationships that basically should be used only for Modify/Notify callbacks.
  This is still subject to refactoring.
*/

61namespace sw
62{
  class ClientIteratorBase;
  struct LegacyModifyHint final: SfxHint
  {
      LegacyModifyHint(const SfxPoolItem* pOld, const SfxPoolItem* pNew) : m_pOld(pOld), m_pNew(pNew) {};
      sal_uInt16 GetWhich() const { return m_pOld ? m_pOld->Which() : m_pNew ? m_pNew->Which() : 0; };
      virtual ~LegacyModifyHint() override;
      const SfxPoolItem* m_pOld;
      const SfxPoolItem* m_pNew;
  };
  struct ModifyChangedHint final: SfxHint
  {
      ModifyChangedHint(const SwModify* pNew) : m_pNew(pNew) {};
      virtual ~ModifyChangedHint() override;
      const SwModify* m_pNew;
  };
  // Observer pattern using svl implementation
  // use this instead of SwClient/SwModify wherever possible
  // In writer layout, this might not always be possible,
  // but for listeners outside of it (e.g. unocore) this should be used.
  // The only "magic" signal this class issues is a ModifyChangedHint
  // proclaiming its death. It does NOT however provide a new SwModify for
  // listeners to switch to like the old SwModify/SwClient did, as that leads
  // to madness.
  class SW_DLLPUBLIC__attribute__ ((visibility("default"))) BroadcasterMixin {
      SvtBroadcaster m_aNotifier;
      public:
          BroadcasterMixin() = default;
          BroadcasterMixin(BroadcasterMixin const &) = default;
          BroadcasterMixin& operator=(const BroadcasterMixin&)
          {
              return *this; // Listeners are never copied or moved.
          }
          SvtBroadcaster& GetNotifier() { return m_aNotifier; }
  };
  /// refactoring out the same of the more sane SwClient functionality
  class SW_DLLPUBLIC__attribute__ ((visibility("default"))) WriterListener
  {
      friend class ::SwModify;
      friend class ::sw::ClientIteratorBase;
      private:
          WriterListener* m_pLeft;
          WriterListener* m_pRight; ///< double-linked list of other clients

          WriterListener(WriterListener const&) = delete;
          WriterListener& operator=(WriterListener const&) = delete;

      protected:
          WriterListener()
              : m_pLeft(nullptr), m_pRight(nullptr)
          {}
          virtual ~WriterListener() COVERITY_NOEXCEPT_FALSE {}
          virtual void SwClientNotify( const SwModify&, const SfxHint& rHint) =0;
      public:
          bool IsLast() const { return !m_pLeft && !m_pRight; }
  };
  enum class IteratorMode { Exact, UnwrapMulti };
119}

121// SwClient
122class SW_DLLPUBLIC__attribute__ ((visibility("default"))) SwClient : public ::sw::WriterListener
123{
  // avoids making the details of the linked list and the callback method public
  friend class SwModify;
  friend class sw::ClientIteratorBase;
  template<typename E, typename S, sw::IteratorMode> friend class SwIterator;

  SwModify *m_pRegisteredIn;        ///< event source

131protected:
  // single argument ctors shall be explicit.
  inline explicit SwClient( SwModify* pToRegisterIn );

  // write access to pRegisteredIn shall be granted only to the object itself (protected access)
  SwModify* GetRegisteredInNonConst() const { return m_pRegisteredIn; }

138public:
  SwClient() : m_pRegisteredIn(nullptr) {}
  SwClient(SwClient&&) noexcept;
  virtual ~SwClient() override;
  // callbacks received from SwModify (friend class - so these methods can be private)
  // should be called only from SwModify the client is registered in
  // mba: IMHO this method should be pure virtual
  // DO NOT USE IN NEW CODE! use SwClientNotify instead.
  virtual void Modify(const SfxPoolItem* pOldValue, const SfxPoolItem* pNewValue);
  // when overriding this, you MUST call SwClient::SwClientModify() in the override!
  virtual void SwClientNotify(const SwModify&, const SfxHint& rHint) override;

  // in case an SwModify object is destroyed that itself is registered in another SwModify,
  // its SwClient objects can decide to get registered to the latter instead by calling this method
  std::unique_ptr<sw::ModifyChangedHint> CheckRegistration( const SfxPoolItem* pOldValue );

  // controlled access to Modify method
  // mba: this is still considered a hack and it should be fixed; the name makes grep-ing easier
  virtual void ModifyNotification( const SfxPoolItem *pOldValue, const SfxPoolItem *pNewValue ) { Modify ( pOldValue, pNewValue ); }
  void SwClientNotifyCall( const SwModify& rModify, const SfxHint& rHint ) { SwClientNotify( rModify, rHint ); }

  const SwModify* GetRegisteredIn() const { return m_pRegisteredIn; }
  SwModify* GetRegisteredIn() { return m_pRegisteredIn; }
  void EndListeningAll();
  void StartListeningToSameModifyAs(const SwClient&);


  // get information about attribute
  virtual bool GetInfo( SfxPoolItem& ) const { return true; }
167};


170// SwModify

172// class has a doubly linked list for dependencies
173class SW_DLLPUBLIC__attribute__ ((visibility("default"))) SwModify: public SwClient
174{
  friend class sw::ClientIteratorBase;
  template<typename E, typename S, sw::IteratorMode> friend class SwIterator;
  sw::WriterListener* m_pWriterListeners;                // the start of the linked list of clients
  bool m_bModifyLocked : 1;         // don't broadcast changes now
  bool m_bLockClientList : 1;       // may be set when this instance notifies its clients
  bool m_bInCache   : 1;
  bool m_bInSwFntCache : 1;

  // mba: IMHO this method should be pure virtual
  // DO NOT USE IN NEW CODE! use CallSwClientNotify instead.
  virtual void Modify( const SfxPoolItem* pOld, const SfxPoolItem *pNew) override
      { NotifyClients( pOld, pNew ); };

  SwModify(SwModify const &) = delete;
  SwModify &operator =(const SwModify&) = delete;
190public:
  SwModify()
      : SwClient(), m_pWriterListeners(nullptr), m_bModifyLocked(false), m_bLockClientList(false), m_bInCache(false), m_bInSwFntCache(false)
  {}

  // broadcasting: send notifications to all clients
  // DO NOT USE IN NEW CODE! use CallSwClientNotify instead.
  void NotifyClients( const SfxPoolItem *pOldValue, const SfxPoolItem *pNewValue );
  // the same, but without setting m_bModifyLocked or checking for any of the flags
  // DO NOT USE IN NEW CODE! use CallSwClientNotify instead.
  void ModifyBroadcast( const SfxPoolItem *pOldValue, const SfxPoolItem *pNewValue)
      { CallSwClientNotify( sw::LegacyModifyHint{ pOldValue, pNewValue } ); };

  // a more universal broadcasting mechanism
  virtual void CallSwClientNotify( const SfxHint& rHint ) const;

  virtual ~SwModify() override;

  void Add(SwClient *pDepend);
  SwClient* Remove(SwClient *pDepend);
  bool HasWriterListeners() const { return m_pWriterListeners; }

  // get information about attribute
  virtual bool GetInfo( SfxPoolItem& ) const override;

  void LockModify()                   { m_bModifyLocked = true;  }
  void UnlockModify()                 { m_bModifyLocked = false; }
  void SetInCache( bool bNew )        { m_bInCache = bNew;       }
  void SetInSwFntCache( bool bNew )   { m_bInSwFntCache = bNew;  }
  void SetInDocDTOR();
  bool IsModifyLocked() const     { return m_bModifyLocked;  }
  bool IsInCache()      const     { return m_bInCache;       }
  bool IsInSwFntCache() const     { return m_bInSwFntCache;  }

  void CheckCaching( const sal_uInt16 nWhich );
  bool HasOnlyOneListener() const { return m_pWriterListeners && m_pWriterListeners->IsLast(); }
226};

228template<typename TElementType, typename TSource, sw::IteratorMode eMode> class SwIterator;

230namespace sw
231{
  // this class is part of the migration: it still forwards the "old"
  // SwModify events and announces them both to the old SwClients still
  // registered and also to the new SvtListeners.
  // Still: in the long run the SwClient/SwModify interface should not be
  // used anymore, in which case a BroadcasterMixin should be enough instead
  // then.
  class SW_DLLPUBLIC__attribute__ ((visibility("default"))) BroadcastingModify : public SwModify, public BroadcasterMixin {
      public:
          virtual void CallSwClientNotify(const SfxHint& rHint) const override;
  };
  // this should be hidden but sadly SwIterator template needs it...
  class ListenerEntry final : public SwClient
  {
  private:
      template<typename E, typename S, sw::IteratorMode> friend class ::SwIterator;
      SwClient *m_pToTell;

  public:
      ListenerEntry(SwClient *const pTellHim, SwModify *const pDepend)
          : SwClient(pDepend), m_pToTell(pTellHim)
      {}
      ListenerEntry(ListenerEntry const &) = delete;
      ListenerEntry& operator=(ListenerEntry const&) = delete;
      ListenerEntry(ListenerEntry&& other) noexcept
          : SwClient(std::move(other))
          , m_pToTell(other.m_pToTell)
      { }
      ListenerEntry& operator=(ListenerEntry&& other) noexcept
      {
          m_pToTell = other.m_pToTell;
          other.GetRegisteredIn()->Add(this);
          other.EndListeningAll();
          return *this;
      }

      /** get Client information */
      virtual bool GetInfo( SfxPoolItem& rInfo) const override;
  private:
      virtual void Modify(const SfxPoolItem* pOldValue, const SfxPoolItem *pNewValue) override;
      virtual void SwClientNotify(const SwModify& rModify, const SfxHint& rHint) override;
  };

  class SW_DLLPUBLIC__attribute__ ((visibility("default"))) WriterMultiListener final
  {
      SwClient& m_rToTell;
      std::vector<ListenerEntry> m_vDepends;
      public:
          WriterMultiListener(SwClient& rToTell);
          WriterMultiListener& operator=(WriterMultiListener const&) = delete; // MSVC2015 workaround
          WriterMultiListener(WriterMultiListener const&) = delete; // MSVC2015 workaround
          ~WriterMultiListener();
          void StartListening(SwModify* pDepend);
          void EndListening(SwModify* pDepend);
          bool IsListeningTo(const SwModify* const pDepend) const;
          void EndListeningAll();
  };
  class ClientIteratorBase : public sw::Ring< ::sw::ClientIteratorBase >
  {
          friend SwClient* SwModify::Remove(SwClient*);
          friend void SwModify::Add(SwClient*);
      protected:
          const SwModify& m_rRoot;
          // the current object in an iteration
          WriterListener* m_pCurrent;
          // in case the current object is already removed, the next object in the list
          // is marked down to become the current object in the next step
          // this is necessary because iteration requires access to members of the current object
          WriterListener* m_pPosition;
          static SW_DLLPUBLIC__attribute__ ((visibility("default"))) ClientIteratorBase* s_pClientIters;

          ClientIteratorBase( const SwModify& rModify )
              : m_rRoot(rModify)
          {
              MoveTo(s_pClientIters);
3
←
Calling 'Ring::MoveTo'→
14
←
Returning from 'Ring::MoveTo'→
              s_pClientIters = this;
              m_pCurrent = m_pPosition = m_rRoot.m_pWriterListeners;
          }
          WriterListener* GetLeftOfPos() { return m_pPosition->m_pLeft; }
          WriterListener* GetRightOfPos() { return m_pPosition->m_pRight; }
          WriterListener* GoStart()
          {
              m_pPosition = m_rRoot.m_pWriterListeners;
              if(m_pPosition)
                  while( m_pPosition->m_pLeft )
                      m_pPosition = m_pPosition->m_pLeft;
              m_pCurrent = m_pPosition;
              return m_pCurrent;
          }
          ~ClientIteratorBase() override
          {
              assert(s_pClientIters)(static_cast <bool> (s_pClientIters) ? void (0) : __assert_fail
 ("s_pClientIters", "/home/maarten/src/libreoffice/core/sw/inc/calbck.hxx"
, 322, __extension__ __PRETTY_FUNCTION__));
              if(s_pClientIters == this)
                  s_pClientIters = unique() ? nullptr : GetNextInRing();
              MoveTo(nullptr);
          }
          // return "true" if an object was removed from a client chain in iteration
          // adding objects to a client chain in iteration is forbidden
          // SwModify::Add() asserts this
          bool IsChanged() const { return m_pPosition != m_pCurrent; }
          // ensures the iterator to point at a current client
          WriterListener* Sync() { m_pCurrent = m_pPosition; return m_pCurrent; }
  };
334}

336template<typename TElementType, typename TSource,
      sw::IteratorMode eMode = sw::IteratorMode::Exact> class SwIterator final
  : private sw::ClientIteratorBase
339{
  //static_assert(!std::is_base_of<SwPageDesc,TSource>::value, "SwPageDesc as TSource is deprecated.");
  static_assert(std::is_base_of<SwClient,TElementType>::value, "TElementType needs to be derived from SwClient.");
  static_assert(std::is_base_of<SwModify,TSource>::value, "TSource needs to be derived from SwModify.");
343public:
  SwIterator( const TSource& rSrc ) : sw::ClientIteratorBase(rSrc) {}
2
←
Calling constructor for 'ClientIteratorBase'→
15
←
Returning from constructor for 'ClientIteratorBase'→
  TElementType* First()
  {
      GoStart();
      if(!m_pPosition)
18
←
Assuming field 'm_pPosition' is non-null, which participates in a condition later→
19
←
Taking false branch→
          return nullptr;
      m_pCurrent = nullptr;
      return Next();
20
←
Calling 'SwIterator::Next'→
27
←
Returning from 'SwIterator::Next'→
28
←
Returning pointer, which participates in a condition later→
  }
  TElementType* Next()
  {
      if(!IsChanged())
21
←
Taking false branch→
          m_pPosition = GetRightOfPos();
      sw::WriterListener *pCurrent(m_pPosition);
      while (m_pPosition)
22
←
Loop condition is true.  Entering loop body→
      {
          if (eMode22.1
is not equal to UnwrapMulti
1
is not equal to UnwrapMulti
1
is not equal to UnwrapMulti
1
is not equal to UnwrapMulti
1
is not equal to UnwrapMulti
 == sw::IteratorMode::UnwrapMulti)
23
←
Taking false branch→
          {
              if (auto const pLE = dynamic_cast<sw::ListenerEntry const*>(m_pPosition))
              {
                  pCurrent = pLE->m_pToTell;
              }
          }
          if (dynamic_cast<const TElementType *>(pCurrent) == nullptr)
24
←
Taking false branch→
          {
              m_pPosition = GetRightOfPos();
              pCurrent = m_pPosition;
          }
          else
              break;
25
←
 Execution continues on line 375→
      }
      Sync();
      return static_cast<TElementType*>(pCurrent);
26
←
Returning pointer (loaded from 'pCurrent'), which participates in a condition later→
  }
  using sw::ClientIteratorBase::IsChanged;
379};

381template< typename TSource > class SwIterator<SwClient, TSource> final : private sw::ClientIteratorBase
382{
  static_assert(std::is_base_of<SwModify,TSource>::value, "TSource needs to be derived from SwModify");
384public:
  SwIterator( const TSource& rSrc ) : sw::ClientIteratorBase(rSrc) {}
  SwClient* First()
      { return static_cast<SwClient*>(GoStart()); }
  SwClient* Next()
  {
      if(!IsChanged())
          m_pPosition = GetRightOfPos();
      return static_cast<SwClient*>(Sync());
  }
  using sw::ClientIteratorBase::IsChanged;
395};

397SwClient::SwClient( SwModify* pToRegisterIn )
  : m_pRegisteredIn( nullptr )
399{
  if(pToRegisterIn)
      pToRegisterIn->Add(this);
402}

404#endif

406/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

←

/home/maarten/src/libreoffice/core/sw/inc/ring.hxx

→

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* 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 .
*/
19#ifndef INCLUDED_SW_INC_RING_HXX
20#define INCLUDED_SW_INC_RING_HXX

22#include <utility>
23#include <sal/types.h>
24#include <iterator>
25#include <type_traits>
26#include <boost/iterator/iterator_facade.hpp>
27#include <boost/intrusive/circular_list_algorithms.hpp>

29namespace sw
30{
  template <typename value_type> class RingContainer;
  template <typename value_type> class RingIterator;
  /**
   * An intrusive container class double linking the contained nodes
   * @example sw/qa/core/uwriter.cxx
   */
  template <typename value_type>
  class SAL_WARN_UNUSED__attribute__((warn_unused)) Ring
  {
      public:
          typedef typename std::add_const<value_type>::type const_value_type;
          typedef RingContainer<value_type> ring_container;
          typedef RingContainer<const_value_type> const_ring_container;
          virtual ~Ring() COVERITY_NOEXCEPT_FALSE
              { unlink(); };
          /** algo::unlink is buggy! don't call it directly! */
          void unlink()
          {
              algo::unlink(this);
5
←
Calling 'circular_list_algorithms::unlink'→
10
←
Returning from 'circular_list_algorithms::unlink'→
              m_pNext = this; // don't leave pointers to old list behind!
              m_pPrev = this;
          }
          /**
           * Removes this item from its current ring container and adds it to
           * another ring container. If the item was not alone in the original
           * ring container, the other items in the ring will stay in the old
           * ring container.
           * Note: the newly created item will be inserted just before item pDestRing.
           * @param pDestRing the container to add this item to
           */
          void MoveTo( value_type* pDestRing );
          /** @return a stl-like container with begin()/end() for iteration */
          ring_container GetRingContainer();
          /** @return a stl-like container with begin()/end() for const iteration */
          const_ring_container GetRingContainer() const;

      protected:
          /**
           * Creates a new item in a ring container all by itself.
           * Note: Ring instances can newer be outside a container. At most, they
           * are alone in one.
           */
          Ring()
              : m_pNext(this)
              , m_pPrev(this)
              { }
          /**
           * Creates a new item and add it to an existing ring container.
           * Note: the newly created item will be inserted just before item pRing.
           * @param pRing ring container to add the created item to
           */
          Ring( value_type* pRing );
          /** @return the next item in the ring container */
          value_type* GetNextInRing()
              { return static_cast<value_type *>(m_pNext); }
          /** @return the previous item in the ring container */
          value_type* GetPrevInRing()
              { return static_cast<value_type *>(m_pPrev); }
          /** @return the next item in the ring container */
          const_value_type* GetNextInRing() const
              { return static_cast<value_type *>(m_pNext); }
          /** @return the previous item in the ring container */
          const_value_type* GetPrevInRing() const
              { return static_cast<value_type *>(m_pPrev); }
          /** @return true if and only if this item is alone in its ring */
          bool unique() const
              { return algo::unique(static_cast< const_value_type* >(this)); }

      private:
          /** internal implementation class -- not for external use */
          struct Ring_node_traits
          {
              typedef Ring node;
              typedef Ring* node_ptr;
              typedef const Ring* const_node_ptr;
              static node_ptr get_next(const_node_ptr n) { return const_cast<node_ptr>(n)->m_pNext; };
              static void set_next(node_ptr n, node_ptr next) { n->m_pNext = next; };
              static node_ptr get_previous(const_node_ptr n) { return const_cast<node_ptr>(n)->m_pPrev; };
              static void set_previous(node_ptr n, node_ptr previous) { n->m_pPrev = previous; };
          };
          friend ring_container;
          friend const_ring_container;
          friend typename ring_container::iterator;
          friend typename ring_container::const_iterator;
          friend typename const_ring_container::iterator;
          friend typename const_ring_container::const_iterator;
          friend class boost::iterator_core_access;
          typedef boost::intrusive::circular_list_algorithms<Ring_node_traits> algo;
          Ring* m_pNext;
          Ring* m_pPrev;
  };

  template <typename value_type>
  inline Ring<value_type>::Ring( value_type* pObj )
      : m_pNext(this)
      , m_pPrev(this)
  {
      if( pObj )
      {
          algo::link_before(pObj, this);
      }
  }

  template <typename value_type>
  inline void Ring<value_type>::MoveTo(value_type* pDestRing)
  {
      value_type* pThis = static_cast< value_type* >(this);
      unlink();
4
←
Calling 'Ring::unlink'→
11
←
Returning from 'Ring::unlink'→
      // insert into "new"
      if (pDestRing)
12
←
Assuming 'pDestRing' is null→
13
←
Taking false branch→
      {
          algo::link_before(pDestRing, pThis);
      }
  }

  /**
   * helper class that provides Svalue_typeL-style container iteration to the ring
   */
  template <typename value_type>
  class SAL_WARN_UNUSED__attribute__((warn_unused)) RingContainer final
  {
      private:
          /** the item in the ring where iteration starts */
          value_type* m_pStart;
          typedef typename std::remove_const<value_type>::type nonconst_value_type;

      public:
          RingContainer( value_type* pRing ) : m_pStart(pRing) {};
          typedef RingIterator<value_type> iterator;
          typedef RingIterator<const value_type> const_iterator;
          /**
           * iterator access
           * @code
           * for(SwPaM& rCurrentPaM : pPaM->GetRingContainer())
           *     do_stuff(rCurrentPaM); // this gets called on every SwPaM in the same ring as pPaM
           * @endcode
           */
          iterator begin();
          iterator end();
          const_iterator begin() const;
          const_iterator end() const;
          /** @return the number of elements in the container */
          size_t size() const
              { return std::distance(begin(), end()); }
          /**
           * Merges two ring containers. All item from both ring containers will
           * be in the same ring container in the end.
           * Note: The items of this ring container will be inserted just before
           * item pDestRing
           * @param pDestRing the container to merge this container with
           */
          void merge( RingContainer< value_type > aDestRing )
          {
              // first check that we aren't merged already, swapping would
              // actually un-merge in this case!
              assert(m_pStart->m_pPrev != aDestRing.m_pStart)(static_cast <bool> (m_pStart->m_pPrev != aDestRing.
m_pStart) ? void (0) : __assert_fail ("m_pStart->m_pPrev != aDestRing.m_pStart"
, "/home/maarten/src/libreoffice/core/sw/inc/ring.hxx", 186, __extension__
 __PRETTY_FUNCTION__));
              assert(m_pStart != aDestRing.m_pStart->m_pPrev)(static_cast <bool> (m_pStart != aDestRing.m_pStart->
m_pPrev) ? void (0) : __assert_fail ("m_pStart != aDestRing.m_pStart->m_pPrev"
, "/home/maarten/src/libreoffice/core/sw/inc/ring.hxx", 187, __extension__
 __PRETTY_FUNCTION__));
              std::swap(m_pStart->m_pPrev->m_pNext, aDestRing.m_pStart->m_pPrev->m_pNext);
              std::swap(m_pStart->m_pPrev, aDestRing.m_pStart->m_pPrev);
          }
  };

  template <typename value_type>
  class RingIterator final : public boost::iterator_facade<
        RingIterator<value_type>
      , value_type
      , boost::forward_traversal_tag
      >
  {
      private:
          typedef typename std::remove_const<value_type>::type nonconst_value_type;
      public:
          RingIterator()
              : m_pCurrent(nullptr)
              , m_pStart(nullptr)
          {}
          explicit RingIterator(nonconst_value_type* pRing, bool bStart = true)
              : m_pCurrent(nullptr)
              , m_pStart(pRing)
          {
              if(!bStart)
                  m_pCurrent = m_pStart;
          }

      private:
          friend class boost::iterator_core_access;
          void increment()
              { m_pCurrent = m_pCurrent ? m_pCurrent->GetNextInRing() : m_pStart->GetNextInRing(); }
          bool equal(RingIterator const& other) const
          {
              // we never want to compare iterators from
              // different rings or starting points
              assert(m_pStart == other.m_pStart)(static_cast <bool> (m_pStart == other.m_pStart) ? void
 (0) : __assert_fail ("m_pStart == other.m_pStart", "/home/maarten/src/libreoffice/core/sw/inc/ring.hxx"
, 223, __extension__ __PRETTY_FUNCTION__));
              return m_pCurrent == other.m_pCurrent;
          }
          value_type& dereference() const
              { return m_pCurrent ? *m_pCurrent : * m_pStart; }
          /**
           * value_type is:
           * - pointing to the current item in the iteration in general
           * - nullptr if on the first item (begin())
           * - m_pStart when beyond the last item (end())
           */
          nonconst_value_type* m_pCurrent;
          /** the first item of the iteration */
          nonconst_value_type* m_pStart;
  };

  template <typename value_type>
  inline typename Ring<value_type>::ring_container Ring<value_type>::GetRingContainer()
      { return Ring<value_type>::ring_container(static_cast< value_type* >(this)); };

  template <typename value_type>
  inline typename Ring<value_type>::const_ring_container Ring<value_type>::GetRingContainer() const
      { return Ring<value_type>::const_ring_container(static_cast< const_value_type* >(this)); };

  template <typename value_type>
  inline typename RingContainer<value_type>::iterator RingContainer<value_type>::begin()
      { return RingContainer<value_type>::iterator(const_cast< nonconst_value_type* >(m_pStart)); };

  template <typename value_type>
  inline typename RingContainer<value_type>::iterator RingContainer<value_type>::end()
      { return RingContainer<value_type>::iterator(const_cast< nonconst_value_type* >(m_pStart), false); };

  template <typename value_type>
  inline typename RingContainer<value_type>::const_iterator RingContainer<value_type>::begin() const
      { return RingContainer<value_type>::const_iterator(const_cast< nonconst_value_type* >(m_pStart)); };

  template <typename value_type>
  inline typename RingContainer<value_type>::const_iterator RingContainer<value_type>::end() const
      { return RingContainer<value_type>::const_iterator(const_cast< nonconst_value_type* >(m_pStart), false); };
262}
263#endif

265/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

←

/home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost/boost/intrusive/circular_list_algorithms.hpp

→

1/////////////////////////////////////////////////////////////////////////////
2//
3// (C) Copyright Olaf Krzikalla 2004-2006.
4// (C) Copyright Ion Gaztanaga  2006-2014
5//
6// Distributed under the Boost Software License, Version 1.0.
7//    (See accompanying file LICENSE_1_0.txt or copy at
8//          http://www.boost.org/LICENSE_1_0.txt)
9//
10// See http://www.boost.org/libs/intrusive for documentation.
11//
12/////////////////////////////////////////////////////////////////////////////

14#ifndef BOOST_INTRUSIVE_CIRCULAR_LIST_ALGORITHMS_HPP
15#define BOOST_INTRUSIVE_CIRCULAR_LIST_ALGORITHMS_HPP

17#include <boost/intrusive/detail/config_begin.hpp>
18#include <boost/intrusive/intrusive_fwd.hpp>
19#include <boost/intrusive/detail/algo_type.hpp>
20#include <boost/core/no_exceptions_support.hpp>
21#include <cstddef>

23#if defined(BOOST_HAS_PRAGMA_ONCE)
24#  pragma once
25#endif

27namespace boost {
28namespace intrusive {

30//! circular_list_algorithms provides basic algorithms to manipulate nodes
31//! forming a circular doubly linked list. An empty circular list is formed by a node
32//! whose pointers point to itself.
33//!
34//! circular_list_algorithms is configured with a NodeTraits class, which encapsulates the
35//! information about the node to be manipulated. NodeTraits must support the
36//! following interface:
37//!
38//! <b>Typedefs</b>:
39//!
40//! <tt>node</tt>: The type of the node that forms the circular list
41//!
42//! <tt>node_ptr</tt>: A pointer to a node
43//!
44//! <tt>const_node_ptr</tt>: A pointer to a const node
45//!
46//! <b>Static functions</b>:
47//!
48//! <tt>static node_ptr get_previous(const_node_ptr n);</tt>
49//!
50//! <tt>static void set_previous(node_ptr n, node_ptr prev);</tt>
51//!
52//! <tt>static node_ptr get_next(const_node_ptr n);</tt>
53//!
54//! <tt>static void set_next(node_ptr n, node_ptr next);</tt>
55template<class NodeTraits>
56class circular_list_algorithms
57{
 public:
 typedef typename NodeTraits::node            node;
 typedef typename NodeTraits::node_ptr        node_ptr;
 typedef typename NodeTraits::const_node_ptr  const_node_ptr;
 typedef NodeTraits                           node_traits;

 //! <b>Effects</b>: Constructs an non-used list element, so that
 //! inited(this_node) == true
 //!
 //! <b>Complexity</b>: Constant
 //!
 //! <b>Throws</b>: Nothing.
 BOOST_INTRUSIVE_FORCEINLINEinline static void init(node_ptr this_node)
 {
    const node_ptr null_node = node_ptr();
    NodeTraits::set_next(this_node, null_node);
    NodeTraits::set_previous(this_node, null_node);
 }

 //! <b>Effects</b>: Returns true is "this_node" is in a non-used state
 //! as if it was initialized by the "init" function.
 //!
 //! <b>Complexity</b>: Constant
 //!
 //! <b>Throws</b>: Nothing.
 BOOST_INTRUSIVE_FORCEINLINEinline static bool inited(const const_node_ptr &this_node)
 {  return !NodeTraits::get_next(this_node); }

 //! <b>Effects</b>: Constructs an empty list, making this_node the only
 //!   node of the circular list:
 //!  <tt>NodeTraits::get_next(this_node) == NodeTraits::get_previous(this_node)
 //!  == this_node</tt>.
 //!
 //! <b>Complexity</b>: Constant
 //!
 //! <b>Throws</b>: Nothing.
 BOOST_INTRUSIVE_FORCEINLINEinline static void init_header(node_ptr this_node)
 {
    NodeTraits::set_next(this_node, this_node);
    NodeTraits::set_previous(this_node, this_node);
 }


 //! <b>Requires</b>: this_node must be in a circular list or be an empty circular list.
 //!
 //! <b>Effects</b>: Returns true is "this_node" is the only node of a circular list:
 //!  <tt>return NodeTraits::get_next(this_node) == this_node</tt>
 //!
 //! <b>Complexity</b>: Constant
 //!
 //! <b>Throws</b>: Nothing.
 BOOST_INTRUSIVE_FORCEINLINEinline static bool unique(const const_node_ptr &this_node)
 {
    node_ptr next = NodeTraits::get_next(this_node);
    return !next || next == this_node;
 }

 //! <b>Requires</b>: this_node must be in a circular list or be an empty circular list.
 //!
 //! <b>Effects</b>: Returns the number of nodes in a circular list. If the circular list
 //!  is empty, returns 1.
 //!
 //! <b>Complexity</b>: Linear
 //!
 //! <b>Throws</b>: Nothing.
 static std::size_t count(const const_node_ptr &this_node)
 {
    std::size_t result = 0;
    const_node_ptr p = this_node;
    do{
       p = NodeTraits::get_next(p);
       ++result;
    }while (p != this_node);
    return result;
 }

 //! <b>Requires</b>: this_node must be in a circular list or be an empty circular list.
 //!
 //! <b>Effects</b>: Unlinks the node from the circular list.
 //!
 //! <b>Complexity</b>: Constant
 //!
 //! <b>Throws</b>: Nothing.
 BOOST_INTRUSIVE_FORCEINLINEinline static node_ptr unlink(node_ptr this_node)
 {
    node_ptr next(NodeTraits::get_next(this_node));
    node_ptr prev(NodeTraits::get_previous(this_node));
    NodeTraits::set_next(prev, next);
6
←
Calling 'Ring_node_traits::set_next'→
7
←
Returning from 'Ring_node_traits::set_next'→
    NodeTraits::set_previous(next, prev);
8
←
Calling 'Ring_node_traits::set_previous'→
9
←
Returning from 'Ring_node_traits::set_previous'→
    return next;
 }

 //! <b>Requires</b>: b and e must be nodes of the same circular list or an empty range.
 //!
 //! <b>Effects</b>: Unlinks the node [b, e) from the circular list.
 //!
 //! <b>Complexity</b>: Constant
 //!
 //! <b>Throws</b>: Nothing.
 BOOST_INTRUSIVE_FORCEINLINEinline static void unlink(node_ptr b, node_ptr e)
 {
    if (b != e) {
       node_ptr prevb(NodeTraits::get_previous(b));
       NodeTraits::set_previous(e, prevb);
       NodeTraits::set_next(prevb, e);
    }
 }

 //! <b>Requires</b>: nxt_node must be a node of a circular list.
 //!
 //! <b>Effects</b>: Links this_node before nxt_node in the circular list.
 //!
 //! <b>Complexity</b>: Constant
 //!
 //! <b>Throws</b>: Nothing.
 BOOST_INTRUSIVE_FORCEINLINEinline static void link_before(node_ptr nxt_node, node_ptr this_node)
 {
    node_ptr prev(NodeTraits::get_previous(nxt_node));
    NodeTraits::set_previous(this_node, prev);
    NodeTraits::set_next(this_node, nxt_node);
    //nxt_node might be an alias for prev->next_
    //so use it before NodeTraits::set_next(prev, ...)
    //is called and the reference changes its value
    NodeTraits::set_previous(nxt_node, this_node);
    NodeTraits::set_next(prev, this_node);
 }

 //! <b>Requires</b>: prev_node must be a node of a circular list.
 //!
 //! <b>Effects</b>: Links this_node after prev_node in the circular list.
 //!
 //! <b>Complexity</b>: Constant
 //!
 //! <b>Throws</b>: Nothing.
 BOOST_INTRUSIVE_FORCEINLINEinline static void link_after(node_ptr prev_node, node_ptr this_node)
 {
    node_ptr next(NodeTraits::get_next(prev_node));
    NodeTraits::set_previous(this_node, prev_node);
    NodeTraits::set_next(this_node, next);
    //prev_node might be an alias for next->next_
    //so use it before update it before NodeTraits::set_previous(next, ...)
    //is called and the reference changes it's value
    NodeTraits::set_next(prev_node, this_node);
    NodeTraits::set_previous(next, this_node);
 }

 //! <b>Requires</b>: this_node and other_node must be nodes inserted
 //!  in circular lists or be empty circular lists.
 //!
 //! <b>Effects</b>: Swaps the position of the nodes: this_node is inserted in
 //!   other_nodes position in the second circular list and the other_node is inserted
 //!   in this_node's position in the first circular list.
 //!
 //! <b>Complexity</b>: Constant
 //!
 //! <b>Throws</b>: Nothing.
 static void swap_nodes(node_ptr this_node, node_ptr other_node)
 {
    if (other_node == this_node)
       return;
    bool this_inited  = inited(this_node);
    bool other_inited = inited(other_node);
    if(this_inited){
       init_header(this_node);
    }
    if(other_inited){
       init_header(other_node);
    }

    node_ptr next_this(NodeTraits::get_next(this_node));
    node_ptr prev_this(NodeTraits::get_previous(this_node));
    node_ptr next_other(NodeTraits::get_next(other_node));
    node_ptr prev_other(NodeTraits::get_previous(other_node));
    //these first two swaps must happen before the other two
    swap_prev(next_this, next_other);
    swap_next(prev_this, prev_other);
    swap_next(this_node, other_node);
    swap_prev(this_node, other_node);

    if(this_inited){
       init(other_node);
    }
    if(other_inited){
       init(this_node);
    }
 }

 //! <b>Requires</b>: b and e must be nodes of the same circular list or an empty range.
 //!   and p must be a node of a different circular list or may not be an iterator in
 //    [b, e).
 //!
 //! <b>Effects</b>: Removes the nodes from [b, e) range from their circular list and inserts
 //!   them before p in p's circular list.
 //!
 //! <b>Complexity</b>: Constant
 //!
 //! <b>Throws</b>: Nothing.
 static void transfer(node_ptr p, node_ptr b, node_ptr e)
 {
    if (b != e) {
       node_ptr prev_p(NodeTraits::get_previous(p));
       node_ptr prev_b(NodeTraits::get_previous(b));
       node_ptr prev_e(NodeTraits::get_previous(e));
       NodeTraits::set_next(prev_e, p);
       NodeTraits::set_previous(p, prev_e);
       NodeTraits::set_next(prev_b, e);
       NodeTraits::set_previous(e, prev_b);
       NodeTraits::set_next(prev_p, b);
       NodeTraits::set_previous(b, prev_p);
    }
 }

 //! <b>Requires</b>: i must a node of a circular list
 //!   and p must be a node of a different circular list.
 //!
 //! <b>Effects</b>: Removes the node i from its circular list and inserts
 //!   it before p in p's circular list.
 //!   If p == i or p == NodeTraits::get_next(i), this function is a null operation.
 //!
 //! <b>Complexity</b>: Constant
 //!
 //! <b>Throws</b>: Nothing.
 static void transfer(node_ptr p, node_ptr i)
 {
    node_ptr n(NodeTraits::get_next(i));
    if(n != p && i != p){
       node_ptr prev_p(NodeTraits::get_previous(p));
       node_ptr prev_i(NodeTraits::get_previous(i));
       NodeTraits::set_next(prev_p, i);
       NodeTraits::set_previous(i, prev_p);
       NodeTraits::set_next(i, p);
       NodeTraits::set_previous(p, i);
       NodeTraits::set_previous(n, prev_i);
       NodeTraits::set_next(prev_i, n);

    }
 }

 //! <b>Effects</b>: Reverses the order of elements in the list.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: This function is linear time.
 static void reverse(node_ptr p)
 {
    node_ptr f(NodeTraits::get_next(p));
    node_ptr i(NodeTraits::get_next(f)), e(p);

    while(i != e) {
       node_ptr n = i;
       i = NodeTraits::get_next(i);
       transfer(f, n, i);
       f = n;
    }
 }

 //! <b>Effects</b>: Moves the node p n positions towards the end of the list.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Linear to the number of moved positions.
 static void move_backwards(node_ptr p, std::size_t n)
 {
    //Null shift, nothing to do
    if(!n) return;
    node_ptr first  = NodeTraits::get_next(p);
    //size() == 0 or 1, nothing to do
    if(first == NodeTraits::get_previous(p)) return;
    unlink(p);
    //Now get the new first node
    while(n--){
       first = NodeTraits::get_next(first);
    }
    link_before(first, p);
 }

 //! <b>Effects</b>: Moves the node p n positions towards the beginning of the list.
 //!
 //! <b>Throws</b>: Nothing.
 //!
 //! <b>Complexity</b>: Linear to the number of moved positions.
 static void move_forward(node_ptr p, std::size_t n)
 {
    //Null shift, nothing to do
    if(!n)   return;
    node_ptr last  = NodeTraits::get_previous(p);
    //size() == 0 or 1, nothing to do
    if(last == NodeTraits::get_next(p))   return;

    unlink(p);
    //Now get the new last node
    while(n--){
       last = NodeTraits::get_previous(last);
    }
    link_after(last, p);
 }

 //! <b>Requires</b>: f and l must be in a circular list.
 //!
 //! <b>Effects</b>: Returns the number of nodes in the range [f, l).
 //!
 //! <b>Complexity</b>: Linear
 //!
 //! <b>Throws</b>: Nothing.
 static std::size_t distance(const const_node_ptr &f, const const_node_ptr &l)
 {
    const_node_ptr i(f);
    std::size_t result = 0;
    while(i != l){
       i = NodeTraits::get_next(i);
       ++result;
    }
    return result;
 }

 struct stable_partition_info
 {
    std::size_t num_1st_partition;
    std::size_t num_2nd_partition;
    node_ptr    beg_2st_partition;
 };

 template<class Pred>
 static void stable_partition(node_ptr beg, node_ptr end, Pred pred, stable_partition_info &info)
 {
    node_ptr bcur = node_traits::get_previous(beg);
    node_ptr cur  = beg;
    node_ptr new_f = end;

    std::size_t num1 = 0, num2 = 0;
    while(cur != end){
       if(pred(cur)){
          ++num1;
          bcur = cur;
          cur  = node_traits::get_next(cur);
       }
       else{
          ++num2;
          node_ptr last_to_remove = bcur;
          new_f = cur;
          bcur = cur;
          cur  = node_traits::get_next(cur);
          BOOST_TRY{ try{
             //Main loop
             while(cur != end){
                if(pred(cur)){ //Might throw
                   ++num1;
                   //Process current node
                   node_traits::set_next    (last_to_remove, cur);
                   node_traits::set_previous(cur, last_to_remove);
                   last_to_remove = cur;
                   node_ptr nxt = node_traits::get_next(cur);
                   node_traits::set_next    (bcur, nxt);
                   node_traits::set_previous(nxt, bcur);
                   cur = nxt;
                }
                else{
                   ++num2;
                   bcur = cur;
                   cur  = node_traits::get_next(cur);
                }
             }
          }
          BOOST_CATCH(...)catch(...){
             node_traits::set_next    (last_to_remove, new_f);
             node_traits::set_previous(new_f, last_to_remove);
             BOOST_RETHROWthrow;;
          }
          BOOST_CATCH_END}
          node_traits::set_next(last_to_remove, new_f);
          node_traits::set_previous(new_f, last_to_remove);
          break;
       }
    }
    info.num_1st_partition = num1;
    info.num_2nd_partition = num2;
    info.beg_2st_partition = new_f;
 }

 private:
 BOOST_INTRUSIVE_FORCEINLINEinline static void swap_prev(node_ptr this_node, node_ptr other_node)
 {
    node_ptr temp(NodeTraits::get_previous(this_node));
    NodeTraits::set_previous(this_node, NodeTraits::get_previous(other_node));
    NodeTraits::set_previous(other_node, temp);
 }

 BOOST_INTRUSIVE_FORCEINLINEinline static void swap_next(node_ptr this_node, node_ptr other_node)
 {
    node_ptr temp(NodeTraits::get_next(this_node));
    NodeTraits::set_next(this_node, NodeTraits::get_next(other_node));
    NodeTraits::set_next(other_node, temp);
 }
451};

453/// @cond

455template<class NodeTraits>
456struct get_algo<CircularListAlgorithms, NodeTraits>
457{
 typedef circular_list_algorithms<NodeTraits> type;
459};

461/// @endcond

463} //namespace intrusive
464} //namespace boost

466#include <boost/intrusive/detail/config_end.hpp>

468#endif //BOOST_INTRUSIVE_CIRCULAR_LIST_ALGORITHMS_HPP

←

/home/maarten/src/libreoffice/core/sw/source/core/inc/frame.hxx

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* 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 .
*/

20#ifndef INCLUDED_SW_SOURCE_CORE_INC_FRAME_HXX
21#define INCLUDED_SW_SOURCE_CORE_INC_FRAME_HXX

23#include <drawinglayer/primitive2d/baseprimitive2d.hxx>
24#include <editeng/borderline.hxx>
25#include <svl/poolitem.hxx>
26#include <swtypes.hxx>
27#include <swrect.hxx>
28#include <calbck.hxx>
29#include <svl/SfxBroadcaster.hxx>
30#include <o3tl/typed_flags_set.hxx>
31#include <com/sun/star/style/TabStop.hpp>
32#include <basegfx/matrix/b2dhommatrix.hxx>
33#include <vcl/outdev.hxx>

35#include <memory>

37namespace drawinglayer::processor2d { class BaseProcessor2D; }

39class SwLayoutFrame;
40class SwRootFrame;
41class SwPageFrame;
42class SwBodyFrame;
43class SwFlyFrame;
44class SwSectionFrame;
45class SwFootnoteFrame;
46class SwFootnoteBossFrame;
47class SwTabFrame;
48class SwRowFrame;
49class SwContentFrame;
50class SwAttrSet;
51class Color;
52class SwBorderAttrs;
53class SwCache;
54class SvxBrushItem;
55class SvxFormatBreakItem;
56class SwFormatPageDesc;
57class SwSelectionList;
58struct SwPosition;
59struct SwCursorMoveState;
60class SwFormat;
61class SwPrintData;
62class SwSortedObjs;
63class SwAnchoredObject;
64enum class SvxFrameDirection;
65class IDocumentDrawModelAccess;

67// Each FrameType is represented here as a bit.
68// The bits must be set in a way that it can be determined with masking of
69// which kind of FrameType an instance is _and_ from what classes it was derived.
70// Each frame has in its base class a member that must be set by the
71// constructors accordingly.
72enum class SwFrameType
73{
  None        = 0x0000,
  Root        = 0x0001,
  Page        = 0x0002,
  Column      = 0x0004,
  Header      = 0x0008,
  Footer      = 0x0010,
  FtnCont     = 0x0020,
  Ftn         = 0x0040,
  Body        = 0x0080,
  Fly         = 0x0100,
  Section     = 0x0200,
85//  UNUSED      0x0400
  Tab         = 0x0800,
  Row         = 0x1000,
  Cell        = 0x2000,
  Txt         = 0x4000,
  NoTxt       = 0x8000,
91};

93namespace o3tl
94{
  template<> struct typed_flags<SwFrameType> : is_typed_flags<SwFrameType, 0xfbff> {};
96};

98// for internal use some common combinations
99#define FRM_LAYOUTSwFrameType(0x3bFF)      SwFrameType(0x3bFF)
100#define FRM_ALLSwFrameType(0xfbff)         SwFrameType(0xfbff)
101#define FRM_CNTNT(SwFrameType::Txt | SwFrameType::NoTxt)       (SwFrameType::Txt | SwFrameType::NoTxt)
102#define FRM_FTNBOSS(SwFrameType::Page | SwFrameType::Column)     (SwFrameType::Page | SwFrameType::Column)
103#define FRM_ACCESSIBLE(SwFrameType::Root | SwFrameType::Page | SwFrameType::Header |
 SwFrameType::Footer | SwFrameType::Ftn | SwFrameType::Fly | SwFrameType
::Tab | SwFrameType::Cell | SwFrameType::Txt)  (SwFrameType::Root | SwFrameType::Page | SwFrameType::Header | SwFrameType::Footer | SwFrameType::Ftn | SwFrameType::Fly | SwFrameType::Tab | SwFrameType::Cell | SwFrameType::Txt)
104#define FRM_NEIGHBOUR(SwFrameType::Column | SwFrameType::Cell)   (SwFrameType::Column | SwFrameType::Cell)
105#define FRM_NOTE_VERT(SwFrameType::FtnCont | SwFrameType::Ftn | SwFrameType::Section
 | SwFrameType::Tab | SwFrameType::Row | SwFrameType::Cell | SwFrameType
::Txt)   (SwFrameType::FtnCont | SwFrameType::Ftn | SwFrameType::Section | SwFrameType::Tab | SwFrameType::Row | SwFrameType::Cell | SwFrameType::Txt)
106#define FRM_HEADFOOT(SwFrameType::Header | SwFrameType::Footer)    (SwFrameType::Header | SwFrameType::Footer)
107#define FRM_BODYFTNC(SwFrameType::FtnCont | SwFrameType::Body)    (SwFrameType::FtnCont | SwFrameType::Body)

109// for GetNextLeaf/GetPrevLeaf.
110enum MakePageType
111{
  MAKEPAGE_NONE,      // do not create page/footnote
  MAKEPAGE_APPEND,    // only append page if needed
  MAKEPAGE_INSERT,    // add or append page if needed
  MAKEPAGE_FTN,       // add footnote if needed
  MAKEPAGE_NOSECTION  // Don't create section frames
117};

119namespace drawinglayer::attribute {
  class SdrAllFillAttributesHelper;
  typedef std::shared_ptr< SdrAllFillAttributesHelper > SdrAllFillAttributesHelperPtr;
122}

124/// Helper class to isolate geometry-defining members of SwFrame
125/// and to control their accesses. Moved to own class to have no
126/// hidden accesses to 'private' members anymore.
127///
128/// Added most important flags about the state of this geometric
129/// information and if it is valid or not
130class SAL_DLLPUBLIC_RTTI__attribute__ ((type_visibility("default"))) SwFrameAreaDefinition
131{
132private:
  friend void FriendHackInvalidateRowFrame(SwFrameAreaDefinition &);

  // The absolute position and size of the SwFrame in the document.
  // This values are set by the layouter implementations
  SwRect  maFrameArea;

  // The 'inner' Frame Area defined by a SwRect relative to FrameArea:
  // When identical to FrameArea, Pos() will be (0, 0) and Size identical.
  SwRect  maFramePrintArea;

  // bitfield
  bool mbFrameAreaPositionValid   : 1;
  bool mbFrameAreaSizeValid       : 1;
  bool mbFramePrintAreaValid      : 1;

  // #i65250#
  // frame ID is now in general available - used for layout loop control
  static sal_uInt32 mnLastFrameId;
  const  sal_uInt32 mnFrameId;

153protected:
  // write access to mb*Valid flags
  void setFrameAreaPositionValid(bool bNew);
  void setFrameAreaSizeValid(bool bNew);
  void setFramePrintAreaValid(bool bNew);

159public:
  SwFrameAreaDefinition();
  virtual ~SwFrameAreaDefinition();

  // read access to mb*Valid flags
  bool isFrameAreaPositionValid() const { return mbFrameAreaPositionValid; }
  bool isFrameAreaSizeValid() const { return mbFrameAreaSizeValid; }
  bool isFramePrintAreaValid() const { return mbFramePrintAreaValid; }

  // syntactic sugar: test whole FrameAreaDefinition
  bool isFrameAreaDefinitionValid() const { return isFrameAreaPositionValid() && isFrameAreaSizeValid() && isFramePrintAreaValid(); }

  // #i65250#
  sal_uInt32 GetFrameId() const { return mnFrameId; }

  // read accesses to FrameArea definitions - only const access allowed.
  // Do *not* const_cast results, it is necessary to track changes. use
  // the below offered WriteAccess helper classes instead
  const SwRect& getFrameArea() const { return maFrameArea; }
  const SwRect& getFramePrintArea() const { return maFramePrintArea; }

  // helper class(es) for FrameArea manipulation. These
  // have to be used to apply changes to FrameAreas. They hold a copy of the
  // SwRect for manipulation. It gets written back at destruction. Thus, this
  // mechanism depends on scope usage, take care. It prevents errors using
  // different instances of SwFrame in get/set methods which is more safe
  class FrameAreaWriteAccess : public SwRect
  {
  private:
      SwFrameAreaDefinition&        mrTarget;

      FrameAreaWriteAccess(const FrameAreaWriteAccess&) = delete;
      FrameAreaWriteAccess& operator=(const FrameAreaWriteAccess&) = delete;

  public:
      FrameAreaWriteAccess(SwFrameAreaDefinition& rTarget) : SwRect(rTarget.getFrameArea()), mrTarget(rTarget) {}
      ~FrameAreaWriteAccess();
      void setSwRect(const SwRect& rNew) { *reinterpret_cast< SwRect* >(this) = rNew; }
  };

  // same helper for FramePrintArea
  class FramePrintAreaWriteAccess : public SwRect
  {
  private:
      SwFrameAreaDefinition&        mrTarget;

      FramePrintAreaWriteAccess(const FramePrintAreaWriteAccess&) = delete;
      FramePrintAreaWriteAccess& operator=(const FramePrintAreaWriteAccess&) = delete;

  public:
      FramePrintAreaWriteAccess(SwFrameAreaDefinition& rTarget) : SwRect(rTarget.getFramePrintArea()), mrTarget(rTarget) {}
      ~FramePrintAreaWriteAccess();
      void setSwRect(const SwRect& rNew) { *reinterpret_cast< SwRect* >(this) = rNew; }
  };

  // RotateFlyFrame3 - Support for Transformations
  // Hand out the Transformations for the current FrameAreaDefinition
  // for the FrameArea and FramePrintArea.
  // FramePrintArea is not relative to FrameArea in this
  // transformation representation (to make it easier to use and understand).
  // There is no 'set' method since SwFrame is a layout object. For
  // some cases rotation will be included (used for SwGrfNode in inner
  // SwFrame of a SwFlyFrame)
  virtual basegfx::B2DHomMatrix getFrameAreaTransformation() const;
  virtual basegfx::B2DHomMatrix getFramePrintAreaTransformation() const;

  // RotateFlyFrame3 - Support for Transformations
  // Modify current transformations by applying given translation
  virtual void transform_translate(const Point& rOffset);
228};

230/// RotateFlyFrame3: Helper class when you want to make your SwFrame derivate
231/// transformable. It provides some tooling to do so. To use, add as member
232/// (see e.g. SwFlyFreeFrame which uses 'std::unique_ptr< TransformableSwFrame >')
233class TransformableSwFrame
234{
235private:
  // The SwFrameAreaDefinition to work on
  SwFrameAreaDefinition&  mrSwFrameAreaDefinition;

  // FrameAreaTransformation and FramePrintAreaTransformation
  // !identity when needed (translate/scale is used (e.g. rotation))
  basegfx::B2DHomMatrix   maFrameAreaTransformation;
  basegfx::B2DHomMatrix   maFramePrintAreaTransformation;

244public:
  TransformableSwFrame(SwFrameAreaDefinition& rSwFrameAreaDefinition)
  :   mrSwFrameAreaDefinition(rSwFrameAreaDefinition),
      maFrameAreaTransformation(),
      maFramePrintAreaTransformation()
  {
  }

  // get SwFrameArea in transformation form
  const basegfx::B2DHomMatrix& getLocalFrameAreaTransformation() const
  {
      return maFrameAreaTransformation;
  }

  // get SwFramePrintArea in transformation form
  const basegfx::B2DHomMatrix& getLocalFramePrintAreaTransformation() const
  {
      return maFramePrintAreaTransformation;
  }

  // Helpers to re-create the untransformed SwRect(s) originally
  // in the SwFrameAreaDefinition, based on the current Transformations.
  SwRect getUntransformedFrameArea() const;
  SwRect getUntransformedFramePrintArea() const;

  // Helper method to re-create FrameAreaTransformations based on the
  // current FrameAreaDefinition transformed by given rotation and Center
  void createFrameAreaTransformations(
      double fRotation,
      const basegfx::B2DPoint& rCenter);

  // Tooling method to reset the SwRect(s) in the current
  // SwFrameAreaDefinition which are already adapted to
  // Transformation back to the untransformed state, using
  // the getUntransformedFrame*Area calls above when needed.
  // Only the SwRect(s) are changed back, not the transformations.
  void restoreFrameAreas();

  // Re-Creates the SwRect(s) as BoundAreas based on the current
  // set Transformations.
  void adaptFrameAreasToTransformations();

  // Modify current definitions by applying the given transformation
  void transform(const basegfx::B2DHomMatrix& aTransform);
288};

290/**
* Base class of the Writer layout elements.
*
* This includes not only fly frames, but everything down to the paragraph
* level: pages, headers, footers, etc. (Inside a paragraph SwLinePortion
* instances are used.)
*/
297class SW_DLLPUBLIC__attribute__ ((visibility("default"))) SwFrame : public SwFrameAreaDefinition, public SwClient, public SfxBroadcaster
298{
  // the hidden Frame
  friend class SwFlowFrame;
  friend class SwLayoutFrame;
  friend class SwLooping;
  friend class SwDeletionChecker; // for GetDep()

  // voids lower during creation of a column
  friend SwFrame *SaveContent( SwLayoutFrame *, SwFrame* pStart );
  friend void   RestoreContent( SwFrame *, SwLayoutFrame *, SwFrame *pSibling );

  // for validating a mistakenly invalidated one in SwContentFrame::MakeAll
  friend void ValidateSz( SwFrame *pFrame );
  // implemented in text/txtftn.cxx, prevents Footnote oscillation
  friend void ValidateText( SwFrame *pFrame );

  friend void MakeNxt( SwFrame *pFrame, SwFrame *pNxt );

  // cache for (border) attributes
  static SwCache *mpCache;

  SwRootFrame   *mpRoot;
  SwLayoutFrame *mpUpper;
  SwFrame       *mpNext;
  SwFrame       *mpPrev;

  // sw_redlinehide: hide these dangerous SwClient functions
  using SwClient::GetRegisteredInNonConst;
  using SwClient::GetRegisteredIn;

  SwFrame *FindNext_();
  SwFrame *FindPrev_();

  /** method to determine next content frame in the same environment
      for a flow frame (content frame, table frame, section frame)

      #i27138# - adding documentation:
      Travelling downwards through the layout to determine the next content
      frame in the same environment. There are several environments in a
      document, which form a closed context regarding this function. These
      environments are:
      - Each page header
      - Each page footer
      - Each unlinked fly frame
      - Each group of linked fly frames
      - All footnotes
      - All document body frames
      #i27138# - adding parameter <_bInSameFootnote>
      Its default value is <false>. If its value is <true>, the environment
      'All footnotes' is no longer treated. Instead each footnote is treated
      as an own environment.

      @param _bInSameFootnote
      input parameter - boolean indicating, that the found next content
      frame has to be in the same footnote frame. This parameter is only
      relevant for flow frames in footnotes.

      @return SwContentFrame*
      pointer to the found next content frame. It's NULL, if none exists.
  */
  SwContentFrame* FindNextCnt_( const bool _bInSameFootnote );

  /** method to determine previous content frame in the same environment
      for a flow frame (content frame, table frame, section frame)

      #i27138#
      Travelling upwards through the layout to determine the previous content
      frame in the same environment. There are several environments in a
      document, which form a closed context regarding this function. These
      environments are:
      - Each page header
      - Each page footer
      - Each unlinked fly frame
      - Each group of linked fly frames
      - All footnotes
      - All document body frames
      #i27138# - adding parameter <_bInSameFootnote>
      Its default value is <false>. If its value is <true>, the environment
      'All footnotes' is no longer treated. Instead each footnote is treated
      as an own environment.

      The found previous content frame has to be in the same footnote frame. This is only
      relevant for flow frames in footnotes.

      @return SwContentFrame*
      pointer to the found previous content frame. It's NULL, if none exists.
  */
  SwContentFrame* FindPrevCnt_();

  void UpdateAttrFrame( const SfxPoolItem*, const SfxPoolItem*, sal_uInt8 & );
  SwFrame* GetIndNext_();
  void SetDirFlags( bool bVert );

  const SwLayoutFrame* ImplGetNextLayoutLeaf( bool bFwd ) const;

  SwPageFrame* ImplFindPageFrame();

395protected:
  std::unique_ptr<SwSortedObjs> m_pDrawObjs; // draw objects, can be null
  SwFrameType mnFrameType;  //Who am I?

  bool mbInDtor      : 1;
  bool mbInvalidR2L  : 1;
  bool mbDerivedR2L  : 1;
  bool mbRightToLeft : 1;
  bool mbInvalidVert : 1;
  bool mbDerivedVert : 1;
  bool mbVertical    : 1;

  bool mbVertLR      : 1;
  bool mbVertLRBT    : 1;

  bool mbValidLineNum  : 1;
  bool mbFixSize       : 1;

  // if true, frame will be painted completely even content was changed
  // only partially. For ContentFrames a border (from Action) will exclusively
  // painted if <mbCompletePaint> is true.
  bool mbCompletePaint : 1;

  bool mbRetouche      : 1; // frame is responsible for retouching

  bool mbInfInvalid    : 1;  // InfoFlags are invalid
  bool mbInfBody       : 1;  // Frame is in document body
  bool mbInfTab        : 1;  // Frame is in a table
  bool mbInfFly        : 1;  // Frame is in a Fly
  bool mbInfFootnote        : 1;  // Frame is in a footnote
  bool mbInfSct        : 1;  // Frame is in a section
  bool mbColLocked     : 1;  // lock Grow/Shrink for column-wise section
                                // or fly frames, will be set in Format
  bool m_isInDestroy : 1;
  bool mbForbidDelete : 1;

  void ColLock()      { mbColLocked = true; }
  void ColUnlock()    { mbColLocked = false; }

  virtual void DestroyImpl();
  virtual ~SwFrame() override;

  // Only used by SwRootFrame Ctor to get 'this' into mpRoot...
  void setRootFrame( SwRootFrame* pRoot ) { mpRoot = pRoot; }

  SwPageFrame *InsertPage( SwPageFrame *pSibling, bool bFootnote );
  void PrepareMake(vcl::RenderContext* pRenderContext);
  void OptPrepareMake();
  virtual void MakePos();
  // Format next frame of table frame to assure keeping attributes.
  // In case of nested tables method <SwFrame::MakeAll()> is called to
  // avoid formatting of superior table frame.
  friend SwFrame* sw_FormatNextContentForKeep( SwTabFrame* pTabFrame );

  virtual void MakeAll(vcl::RenderContext* pRenderContext) = 0;
  // adjust frames of a page
  SwTwips AdjustNeighbourhood( SwTwips nDiff, bool bTst = false );

  // change only frame size not the size of PrtArea
  virtual SwTwips ShrinkFrame( SwTwips, bool bTst = false, bool bInfo = false ) = 0;
  virtual SwTwips GrowFrame  ( SwTwips, bool bTst = false, bool bInfo = false ) = 0;

  /// use these so we can grep for SwFrame's GetRegisteredIn accesses
  /// beware that SwTextFrame may return sw::WriterMultiListener
  SwModify        *GetDep()       { return GetRegisteredInNonConst(); }
  const SwModify  *GetDep() const { return GetRegisteredIn(); }

  SwFrame( SwModify*, SwFrame* );

  void CheckDir( SvxFrameDirection nDir, bool bVert, bool bOnlyBiDi, bool bBrowse );

  /** enumeration for the different invalidations
      #i28701#
  */
  enum InvalidationType
  {
      INVALID_SIZE, INVALID_PRTAREA, INVALID_POS, INVALID_LINENUM, INVALID_ALL
  };

  /** method to determine, if an invalidation is allowed.
      #i28701
  */
  virtual bool InvalidationAllowed( const InvalidationType _nInvalid ) const;

  /** method to perform additional actions on an invalidation

      #i28701#
      Method has *only* to contain actions, which has to be performed on
      *every* assignment of the corresponding flag to <false>.
  */
  virtual void ActionOnInvalidation( const InvalidationType _nInvalid );

  // draw shadow and borders
  void PaintShadow( const SwRect&, SwRect&, const SwBorderAttrs& ) const;
  virtual void Modify( const SfxPoolItem*, const SfxPoolItem* ) override;

  virtual const IDocumentDrawModelAccess& getIDocumentDrawModelAccess( );

493public:
  virtual css::uno::Sequence< css::style::TabStop > GetTabStopInfo( SwTwips )
  {
      return css::uno::Sequence< css::style::TabStop >();
  }


  SwFrameType GetType() const { return mnFrameType; }

  static SwCache &GetCache()                { return *mpCache; }
  static SwCache *GetCachePtr()             { return mpCache;  }
  static void     SetCache( SwCache *pNew ) { mpCache = pNew;  }

  // change PrtArea size and FrameSize
  SwTwips Shrink( SwTwips, bool bTst = false, bool bInfo = false );
  SwTwips Grow  ( SwTwips, bool bTst = false, bool bInfo = false );

  // different methods for inserting in layout tree (for performance reasons)

  // insert before pBehind or at the end of the chain below mpUpper
  void InsertBefore( SwLayoutFrame* pParent, SwFrame* pBehind );
  // insert after pBefore or at the beginning of the chain below mpUpper
  void InsertBehind( SwLayoutFrame *pParent, SwFrame *pBefore );
  // insert before pBehind or at the end of the chain while considering
  // the siblings of pSct
  bool InsertGroupBefore( SwFrame* pParent, SwFrame* pWhere, SwFrame* pSct );
  void RemoveFromLayout();

  // For internal use only - who ignores this will be put in a sack and has
  // to stay there for two days
  // Does special treatment for Get_[Next|Prev]Leaf() (for tables).
  SwLayoutFrame *GetLeaf( MakePageType eMakePage, bool bFwd );
  SwLayoutFrame *GetNextLeaf   ( MakePageType eMakePage );
  SwLayoutFrame *GetNextFootnoteLeaf( MakePageType eMakePage );
  SwLayoutFrame *GetNextSctLeaf( MakePageType eMakePage );
  SwLayoutFrame *GetNextCellLeaf();
  SwLayoutFrame *GetPrevLeaf   ();
  SwLayoutFrame *GetPrevFootnoteLeaf( MakePageType eMakeFootnote );
  SwLayoutFrame *GetPrevSctLeaf();
  SwLayoutFrame *GetPrevCellLeaf();
  const SwLayoutFrame *GetLeaf ( MakePageType eMakePage, bool bFwd,
                               const SwFrame *pAnch ) const;

  bool WrongPageDesc( SwPageFrame* pNew );

  //#i28701# - new methods to append/remove drawing objects
  void AppendDrawObj( SwAnchoredObject& _rNewObj );
  void RemoveDrawObj( SwAnchoredObject& _rToRemoveObj );

  // work with chain of FlyFrames
  void  AppendFly( SwFlyFrame *pNew );
  void  RemoveFly( SwFlyFrame *pToRemove );
  const SwSortedObjs *GetDrawObjs() const { return m_pDrawObjs.get(); }
        SwSortedObjs *GetDrawObjs()       { return m_pDrawObjs.get(); }
  // #i28701# - change purpose of method and adjust its name
  void InvalidateObjs( const bool _bNoInvaOfAsCharAnchoredObjs = true );

  virtual void PaintSwFrameShadowAndBorder(
      const SwRect&,
      const SwPageFrame* pPage,
      const SwBorderAttrs&) const;
  void PaintBaBo( const SwRect&, const SwPageFrame *pPage,
                  const bool bOnlyTextBackground = false) const;
  void PaintSwFrameBackground( const SwRect&, const SwPageFrame *pPage,
                        const SwBorderAttrs &,
                        const bool bLowerMode = false,
                        const bool bLowerBorder = false,
                        const bool bOnlyTextBackground = false ) const;
  void PaintBorderLine( const SwRect&, const SwRect&, const SwPageFrame*,
                        const Color *pColor,
                        const SvxBorderLineStyle = SvxBorderLineStyle::SOLID ) const;

  std::unique_ptr<drawinglayer::processor2d::BaseProcessor2D> CreateProcessor2D( ) const;
  void ProcessPrimitives( const drawinglayer::primitive2d::Primitive2DContainer& rSequence ) const;

  // retouch, not in the area of the given Rect!
  void Retouch( const SwPageFrame *pPage, const SwRect &rRect ) const;

  bool GetBackgroundBrush(
      drawinglayer::attribute::SdrAllFillAttributesHelperPtr& rFillAttributes,
      const SvxBrushItem*& rpBrush,
      const Color*& rpColor,
      SwRect &rOrigRect,
      bool bLowerMode,
      bool bConsiderTextBox ) const;

  inline void SetCompletePaint() const;
  inline void ResetCompletePaint() const;
  bool IsCompletePaint() const { return mbCompletePaint; }

  inline void SetRetouche() const;
  inline void ResetRetouche() const;
  bool IsRetouche() const { return mbRetouche; }

  void SetInfFlags();
  void InvalidateInfFlags() { mbInfInvalid = true; }
  inline bool IsInDocBody() const;    // use InfoFlags, determine flags
  inline bool IsInFootnote() const;        // if necessary
  inline bool IsInTab() const;
  inline bool IsInFly() const;
  inline bool IsInSct() const;

  // If frame is inside a split table row, this function returns
  // the corresponding row frame in the follow table.
  const SwRowFrame* IsInSplitTableRow() const;

  // If frame is inside a follow flow row, this function returns
  // the corresponding row frame master table
  const SwRowFrame* IsInFollowFlowRow() const;

  bool IsInBalancedSection() const;

  inline bool IsVertical() const;
  inline bool IsVertLR() const;
  inline bool IsVertLRBT() const;

  void SetDerivedVert( bool bNew ){ mbDerivedVert = bNew; }
  void SetInvalidVert( bool bNew) { mbInvalidVert = bNew; }
  inline bool IsRightToLeft() const;
  void SetDerivedR2L( bool bNew ) { mbDerivedR2L  = bNew; }

  void CheckDirChange();
  // returns upper left frame position for LTR and
  // upper right frame position for Asian / RTL frames
  Point   GetFrameAnchorPos( bool bIgnoreFlysAnchoredAtThisFrame ) const;

  /** determine, if frame is moveable in given environment

      method replaced 'old' method <bool IsMoveable() const>.
      Determines, if frame is moveable in given environment. if no environment
      is given (parameter _pLayoutFrame == 0), the movability in the actual
      environment (<GetUpper()) is checked.

      @param _pLayoutFrame
      input parameter - given environment (layout frame), in which the movability
      will be checked. If not set ( == 0 ), actual environment is taken.

      @return boolean, indicating, if frame is moveable in given environment
  */
  bool IsMoveable( const SwLayoutFrame* _pLayoutFrame = nullptr ) const;

  // Is it permitted for the (Text)Frame to add a footnote in the current
  // environment (not e.g. for repeating table headlines)
  bool IsFootnoteAllowed() const;

  virtual void  Format( vcl::RenderContext* pRenderContext, const SwBorderAttrs *pAttrs = nullptr );

  virtual void CheckDirection( bool bVert );

  void ReinitializeFrameSizeAttrFlags();

  /// WARNING: this may not return correct RES_PAGEDESC/RES_BREAK items for
  /// SwTextFrame, use GetBreakItem()/GetPageDescItem() instead
  const SwAttrSet *GetAttrSet() const;
  virtual const SvxFormatBreakItem& GetBreakItem() const;
  virtual const SwFormatPageDesc& GetPageDescItem() const;

  bool HasFixSize() const { return mbFixSize; }

  // check all pages (starting from the given) and correct them if needed
  static void CheckPageDescs( SwPageFrame *pStart, bool bNotifyFields = true, SwPageFrame** ppPrev = nullptr);

  // might return 0, with and without const
  SwFrame               *GetNext()  { return mpNext; }
  SwFrame               *GetPrev()  { return mpPrev; }
  SwLayoutFrame         *GetUpper() { return mpUpper; }
  SwRootFrame           *getRootFrame(){ return mpRoot; }
  SwPageFrame           *FindPageFrame() { return IsPageFrame() ? reinterpret_cast<SwPageFrame*>(this) : ImplFindPageFrame(); }
  SwFrame               *FindColFrame();
  SwRowFrame            *FindRowFrame();
  SwFootnoteBossFrame   *FindFootnoteBossFrame( bool bFootnotes = false );
  SwTabFrame            *ImplFindTabFrame();
  SwFootnoteFrame       *ImplFindFootnoteFrame();
  SwFlyFrame            *ImplFindFlyFrame();
  SwSectionFrame        *ImplFindSctFrame();
  const SwBodyFrame     *ImplFindBodyFrame() const;
  SwFrame               *FindFooterOrHeader();
  SwFrame               *GetLower();
  const SwFrame         *GetNext()  const { return mpNext; }
  const SwFrame         *GetPrev()  const { return mpPrev; }
  const SwLayoutFrame   *GetUpper() const { return mpUpper; }
  const SwRootFrame     *getRootFrame()   const { return mpRoot; }
  inline SwTabFrame     *FindTabFrame();
  inline SwFootnoteFrame     *FindFootnoteFrame();
  inline SwFlyFrame     *FindFlyFrame();
  inline SwSectionFrame *FindSctFrame();
  inline SwFrame        *FindNext();
  // #i27138# - add parameter <_bInSameFootnote>
  SwContentFrame* FindNextCnt( const bool _bInSameFootnote = false );
  inline SwFrame        *FindPrev();
  inline const SwPageFrame *FindPageFrame() const;
  inline const SwFootnoteBossFrame *FindFootnoteBossFrame( bool bFootnote = false ) const;
  inline const SwFrame     *FindColFrame() const;
  inline const SwFrame     *FindFooterOrHeader() const;
  inline const SwTabFrame  *FindTabFrame() const;
  inline const SwFootnoteFrame  *FindFootnoteFrame() const;
  inline const SwFlyFrame  *FindFlyFrame() const;
  inline const SwSectionFrame *FindSctFrame() const;
  inline const SwBodyFrame    *FindBodyFrame() const;
  inline const SwFrame     *FindNext() const;
  // #i27138# - add parameter <_bInSameFootnote>
  const SwContentFrame* FindNextCnt( const bool _bInSameFootnote = false ) const;
  inline const SwFrame     *FindPrev() const;
         const SwFrame     *GetLower()  const;

  SwContentFrame* FindPrevCnt();

  const SwContentFrame* FindPrevCnt() const;

  // #i79774#
  SwFrame* GetIndPrev_() const;
  SwFrame* GetIndPrev() const
      { return ( mpPrev || !IsInSct() ) ? mpPrev : GetIndPrev_(); }

  SwFrame* GetIndNext()
      { return ( mpNext || !IsInSct() ) ? mpNext : GetIndNext_(); }
  const SwFrame* GetIndNext() const { return const_cast<SwFrame*>(this)->GetIndNext(); }

  sal_uInt16 GetPhyPageNum() const;   // page number without offset
  sal_uInt16 GetVirtPageNum() const;  // page number with offset
  bool OnRightPage() const { return 0 != GetPhyPageNum() % 2; };
  bool WannaRightPage() const;
  bool OnFirstPage() const;

  inline const  SwLayoutFrame *GetPrevLayoutLeaf() const;
  inline const  SwLayoutFrame *GetNextLayoutLeaf() const;
  inline SwLayoutFrame *GetPrevLayoutLeaf();
  inline SwLayoutFrame *GetNextLayoutLeaf();

  virtual void Calc(vcl::RenderContext* pRenderContext) const; // here might be "formatted"
  inline void OptCalc() const;    // here we assume (for optimization) that
                                  // the predecessors are already formatted
  Point   GetRelPos() const;

  // PaintArea is the area where content might be displayed.
  // The margin of a page or the space between columns belongs to it.
  SwRect GetPaintArea() const;

  // UnionFrame is the union of Frame- and PrtArea, normally identical
  // to the FrameArea except in case of negative Prt margins.
  SwRect UnionFrame( bool bBorder = false ) const;

  virtual Size ChgSize( const Size& aNewSize );

  virtual void Cut() = 0;
  virtual void Paste( SwFrame* pParent, SwFrame* pSibling = nullptr ) = 0;

  void ValidateLineNum() { mbValidLineNum = true; }

  bool GetValidLineNumFlag()const { return mbValidLineNum; }

  // Only invalidate Frame
  // #i28701# - add call to method <ActionOnInvalidation(..)>
  //            for all invalidation methods.
  // #i28701# - use method <InvalidationAllowed(..)> to
  //            decide, if invalidation will to be performed or not.
  // #i26945# - no additional invalidation, if it's already
  //            invalidate.
  void InvalidateSize_()
  {
      if ( isFrameAreaSizeValid() && InvalidationAllowed( INVALID_SIZE ) )
      {
          setFrameAreaSizeValid(false);
          ActionOnInvalidation( INVALID_SIZE );
      }
  }
  void InvalidatePrt_()
  {
      if ( isFramePrintAreaValid() && InvalidationAllowed( INVALID_PRTAREA ) )
      {
          setFramePrintAreaValid(false);
          ActionOnInvalidation( INVALID_PRTAREA );
      }
  }
  void InvalidatePos_()
  {
      if ( isFrameAreaPositionValid() && InvalidationAllowed( INVALID_POS ) )
      {
          setFrameAreaPositionValid(false);
          ActionOnInvalidation( INVALID_POS );
      }
  }
  void InvalidateLineNum_()
  {
      if ( mbValidLineNum && InvalidationAllowed( INVALID_LINENUM ) )
      {
          mbValidLineNum = false;
          ActionOnInvalidation( INVALID_LINENUM );
      }
  }
  void InvalidateAll_()
  {
      if ( ( isFrameAreaSizeValid() || isFramePrintAreaValid() || isFrameAreaPositionValid() ) && InvalidationAllowed( INVALID_ALL ) )
      {
          setFrameAreaSizeValid(false);
          setFrameAreaPositionValid(false);
          setFramePrintAreaValid(false);
          ActionOnInvalidation( INVALID_ALL );
      }
  }
  // also notify page at the same time
  inline void InvalidateSize();
  inline void InvalidatePrt();
  inline void InvalidatePos();
  inline void InvalidateLineNum();
  inline void InvalidateAll();
  void ImplInvalidateSize();
  void ImplInvalidatePrt();
  void ImplInvalidatePos();
  void ImplInvalidateLineNum();

  inline void InvalidateNextPos( bool bNoFootnote = false );
  void ImplInvalidateNextPos( bool bNoFootnote );

  /** method to invalidate printing area of next frame
      #i11859#
  */
  void InvalidateNextPrtArea();

  void InvalidatePage( const SwPageFrame *pPage = nullptr ) const;

  virtual bool    FillSelection( SwSelectionList& rList, const SwRect& rRect ) const;

  virtual bool    GetModelPositionForViewPoint( SwPosition *, Point&,
                               SwCursorMoveState* = nullptr, bool bTestBackground = false ) const;
  virtual bool    GetCharRect( SwRect &, const SwPosition&,
                               SwCursorMoveState* = nullptr, bool bAllowFarAway = true ) const;
  virtual void PaintSwFrame( vcl::RenderContext& rRenderContext, SwRect const&,
                      SwPrintData const*const pPrintData = nullptr ) const;

  // HACK: shortcut between frame and formatting
  // It's your own fault if you cast void* incorrectly! In any case check
  // the void* for 0.
  virtual bool Prepare( const PrepareHint ePrep = PrepareHint::Clear,
                        const void *pVoid = nullptr, bool bNotify = true );

  // true if it is the correct class, false otherwise
  inline bool IsLayoutFrame() const;
  inline bool IsRootFrame() const;
  inline bool IsPageFrame() const;
  inline bool IsColumnFrame() const;
  inline bool IsFootnoteBossFrame() const;  // footnote bosses might be PageFrames or ColumnFrames
  inline bool IsHeaderFrame() const;
  inline bool IsFooterFrame() const;
  inline bool IsFootnoteContFrame() const;
  inline bool IsFootnoteFrame() const;
  inline bool IsBodyFrame() const;
  inline bool IsColBodyFrame() const;  // implemented in layfrm.hxx, BodyFrame above ColumnFrame
  inline bool IsPageBodyFrame() const; // implemented in layfrm.hxx, BodyFrame above PageFrame
  inline bool IsFlyFrame() const;
  inline bool IsSctFrame() const;
  inline bool IsTabFrame() const;
  inline bool IsRowFrame() const;
  inline bool IsCellFrame() const;
  inline bool IsContentFrame() const;
  inline bool IsTextFrame() const;
  inline bool IsNoTextFrame() const;
  // Frames where its PrtArea depends on their neighbors and that are
  // positioned in the content flow
  inline bool IsFlowFrame() const;
  // Frames that are capable of retouching or that might need to retouch behind
  // themselves
  inline bool IsRetoucheFrame() const;
  inline bool IsAccessibleFrame() const;

  void PrepareCursor();                 // CursorShell is allowed to call this

  // Is the Frame (or the section containing it) protected? Same for Fly in
  // Fly in ... and footnotes
  bool IsProtected() const;

  bool IsColLocked()  const { return mbColLocked; }
  virtual bool IsDeleteForbidden() const { return mbForbidDelete; }

  /// this is the only way to delete a SwFrame instance
  static void DestroyFrame(SwFrame *const pFrame);

  bool IsInDtor() const { return mbInDtor; }

  // No inline cause we need the function pointers
  long GetTopMargin() const;
  long GetBottomMargin() const;
  long GetLeftMargin() const;
  long GetRightMargin() const;
  void SetTopBottomMargins( long, long );
  void SetLeftRightMargins( long, long );
  void SetRightLeftMargins( long, long );
  long GetPrtLeft() const;
  long GetPrtBottom() const;
  long GetPrtRight() const;
  long GetPrtTop() const;
  bool SetMinLeft( long );
  bool SetMaxBottom( long );
  bool SetMaxRight( long );
  void MakeBelowPos( const SwFrame*, const SwFrame*, bool );
  void MakeLeftPos( const SwFrame*, const SwFrame*, bool );
  void MakeRightPos( const SwFrame*, const SwFrame*, bool );
  bool IsNeighbourFrame() const
      { return bool(GetType() & FRM_NEIGHBOUR(SwFrameType::Column | SwFrameType::Cell)); }

  // NEW TABLES
  // Some functions for covered/covering table cells. This way unnecessary
  // includes can be avoided
  virtual bool IsLeaveUpperAllowed() const;
  virtual bool IsCoveredCell() const;
  bool IsInCoveredCell() const;

  // #i81146# new loop control
  bool KnowsFormat( const SwFormat& rFormat ) const;
  void RegisterToFormat( SwFormat& rFormat );
  void ValidateThisAndAllLowers( const sal_uInt16 nStage );

  void ForbidDelete()      { mbForbidDelete = true; }
  void AllowDelete()    { mbForbidDelete = false; }

  drawinglayer::attribute::SdrAllFillAttributesHelperPtr getSdrAllFillAttributesHelper() const;
  bool supportsFullDrawingLayerFillAttributeSet() const;

911public:
  // if writer is NULL, dumps the layout structure as XML in layout.xml
  virtual void dumpAsXml(xmlTextWriterPtr writer = nullptr) const;
  void dumpTopMostAsXml(xmlTextWriterPtr writer = nullptr) const;
  void dumpInfosAsXml(xmlTextWriterPtr writer) const;
  virtual void dumpAsXmlAttributes(xmlTextWriterPtr writer) const;
  void dumpChildrenAsXml(xmlTextWriterPtr writer) const;
  bool IsCollapse() const;
919};

921inline bool SwFrame::IsInDocBody() const
922{
  if ( mbInfInvalid )
      const_cast<SwFrame*>(this)->SetInfFlags();
  return mbInfBody;
926}
927inline bool SwFrame::IsInFootnote() const
928{
  if ( mbInfInvalid )
      const_cast<SwFrame*>(this)->SetInfFlags();
  return mbInfFootnote;
932}
933inline bool SwFrame::IsInTab() const
934{
  if ( mbInfInvalid )
      const_cast<SwFrame*>(this)->SetInfFlags();
  return mbInfTab;
938}
939inline bool SwFrame::IsInFly() const
940{
  if ( mbInfInvalid )
      const_cast<SwFrame*>(this)->SetInfFlags();
  return mbInfFly;
944}
945inline bool SwFrame::IsInSct() const
946{
  if ( mbInfInvalid )
      const_cast<SwFrame*>(this)->SetInfFlags();
  return mbInfSct;
950}
951bool SwFrame::IsVertical() const
952{
  if( mbInvalidVert )
      const_cast<SwFrame*>(this)->SetDirFlags( true );
  return mbVertical;
956}
957inline bool SwFrame::IsVertLR() const
958{
  return mbVertLR;
960}
961inline bool SwFrame::IsVertLRBT() const
962{
  return mbVertLRBT;
964}
965inline bool SwFrame::IsRightToLeft() const
966{
  if( mbInvalidR2L )
      const_cast<SwFrame*>(this)->SetDirFlags( false );
  return mbRightToLeft;
970}

972inline void SwFrame::SetCompletePaint() const
973{
  const_cast<SwFrame*>(this)->mbCompletePaint = true;
975}
976inline void SwFrame::ResetCompletePaint() const
977{
  const_cast<SwFrame*>(this)->mbCompletePaint = false;
979}

981inline void SwFrame::SetRetouche() const
982{
  const_cast<SwFrame*>(this)->mbRetouche = true;
984}
985inline void SwFrame::ResetRetouche() const
986{
  const_cast<SwFrame*>(this)->mbRetouche = false;
988}

990inline SwLayoutFrame *SwFrame::GetNextLayoutLeaf()
991{
  return const_cast<SwLayoutFrame*>(static_cast<const SwFrame*>(this)->GetNextLayoutLeaf());
993}
994inline SwLayoutFrame *SwFrame::GetPrevLayoutLeaf()
995{
  return const_cast<SwLayoutFrame*>(static_cast<const SwFrame*>(this)->GetPrevLayoutLeaf());
997}
998inline const SwLayoutFrame *SwFrame::GetNextLayoutLeaf() const
999{
  return ImplGetNextLayoutLeaf( true );
1001}
1002inline const SwLayoutFrame *SwFrame::GetPrevLayoutLeaf() const
1003{
  return ImplGetNextLayoutLeaf( false );
1005}

1007inline void SwFrame::InvalidateSize()
1008{
  if ( isFrameAreaSizeValid() )
  {
      ImplInvalidateSize();
  }
1013}
1014inline void SwFrame::InvalidatePrt()
1015{
  if ( isFramePrintAreaValid() )
  {
      ImplInvalidatePrt();
  }
1020}
1021inline void SwFrame::InvalidatePos()
1022{
  if ( isFrameAreaPositionValid() )
  {
      ImplInvalidatePos();
  }
1027}
1028inline void SwFrame::InvalidateLineNum()
1029{
  if ( mbValidLineNum )
      ImplInvalidateLineNum();
1032}
1033inline void SwFrame::InvalidateAll()
1034{
  if ( InvalidationAllowed( INVALID_ALL ) )
  {
      if ( isFrameAreaDefinitionValid()  )
      {
          ImplInvalidatePos();
      }

      setFrameAreaSizeValid(false);
      setFrameAreaPositionValid(false);
      setFramePrintAreaValid(false);

      // #i28701#
      ActionOnInvalidation( INVALID_ALL );
  }
1049}
1050inline void SwFrame::InvalidateNextPos( bool bNoFootnote )
1051{
  if ( mpNext && !mpNext->IsSctFrame() )
      mpNext->InvalidatePos();
  else
      ImplInvalidateNextPos( bNoFootnote );
1056}

1058inline void SwFrame::OptCalc() const
1059{
  if ( !isFrameAreaPositionValid() || !isFramePrintAreaValid() || !isFrameAreaSizeValid() )
  {
      const_cast<SwFrame*>(this)->OptPrepareMake();
  }
1064}
1065inline const SwPageFrame *SwFrame::FindPageFrame() const
1066{
  return const_cast<SwFrame*>(this)->FindPageFrame();
1068}
1069inline const SwFrame *SwFrame::FindColFrame() const
1070{
  return const_cast<SwFrame*>(this)->FindColFrame();
1072}
1073inline const SwFrame *SwFrame::FindFooterOrHeader() const
1074{
  return const_cast<SwFrame*>(this)->FindFooterOrHeader();
1076}
1077inline SwTabFrame *SwFrame::FindTabFrame()
1078{
  return IsInTab() ? ImplFindTabFrame() : nullptr;
34
←
Assuming the condition is true→
35
←
'?' condition is true→
36
←
Returning pointer, which participates in a condition later→
37
←
Returning pointer→
1080}
1081inline const SwFootnoteBossFrame *SwFrame::FindFootnoteBossFrame( bool bFootnote ) const
1082{
  return const_cast<SwFrame*>(this)->FindFootnoteBossFrame( bFootnote );
1084}
1085inline SwFootnoteFrame *SwFrame::FindFootnoteFrame()
1086{
  return IsInFootnote() ? ImplFindFootnoteFrame() : nullptr;
1088}
1089inline SwFlyFrame *SwFrame::FindFlyFrame()
1090{
  return IsInFly() ? ImplFindFlyFrame() : nullptr;
1092}
1093inline SwSectionFrame *SwFrame::FindSctFrame()
1094{
  return IsInSct() ? ImplFindSctFrame() : nullptr;
1096}

1098inline const SwBodyFrame *SwFrame::FindBodyFrame() const
1099{
  return IsInDocBody() ? ImplFindBodyFrame() : nullptr;
1101}

1103inline const SwTabFrame *SwFrame::FindTabFrame() const
1104{
  return IsInTab() ? const_cast<SwFrame*>(this)->ImplFindTabFrame() : nullptr;
1106}
1107inline const SwFootnoteFrame *SwFrame::FindFootnoteFrame() const
1108{
  return IsInFootnote() ? const_cast<SwFrame*>(this)->ImplFindFootnoteFrame() : nullptr;
1110}
1111inline const SwFlyFrame *SwFrame::FindFlyFrame() const
1112{
  return IsInFly() ? const_cast<SwFrame*>(this)->ImplFindFlyFrame() : nullptr;
1114}
1115inline const SwSectionFrame *SwFrame::FindSctFrame() const
1116{
  return IsInSct() ? const_cast<SwFrame*>(this)->ImplFindSctFrame() : nullptr;
1118}
1119inline SwFrame *SwFrame::FindNext()
1120{
  if ( mpNext )
      return mpNext;
  else
      return FindNext_();
1125}
1126inline const SwFrame *SwFrame::FindNext() const
1127{
  if ( mpNext )
      return mpNext;
  else
      return const_cast<SwFrame*>(this)->FindNext_();
1132}
1133inline SwFrame *SwFrame::FindPrev()
1134{
  if ( mpPrev && !mpPrev->IsSctFrame() )
      return mpPrev;
  else
      return FindPrev_();
1139}
1140inline const SwFrame *SwFrame::FindPrev() const
1141{
  if ( mpPrev && !mpPrev->IsSctFrame() )
      return mpPrev;
  else
      return const_cast<SwFrame*>(this)->FindPrev_();
1146}

1148inline bool SwFrame::IsLayoutFrame() const
1149{
  return bool(GetType() & FRM_LAYOUTSwFrameType(0x3bFF));
1151}
1152inline bool SwFrame::IsRootFrame() const
1153{
  return mnFrameType == SwFrameType::Root;
1155}
1156inline bool SwFrame::IsPageFrame() const
1157{
  return mnFrameType == SwFrameType::Page;
1159}
1160inline bool SwFrame::IsColumnFrame() const
1161{
  return mnFrameType == SwFrameType::Column;
1163}
1164inline bool SwFrame::IsFootnoteBossFrame() const
1165{
  return bool(GetType() & FRM_FTNBOSS(SwFrameType::Page | SwFrameType::Column));
1167}
1168inline bool SwFrame::IsHeaderFrame() const
1169{
  return mnFrameType == SwFrameType::Header;
1171}
1172inline bool SwFrame::IsFooterFrame() const
1173{
  return mnFrameType == SwFrameType::Footer;
1175}
1176inline bool SwFrame::IsFootnoteContFrame() const
1177{
  return mnFrameType == SwFrameType::FtnCont;
1179}
1180inline bool SwFrame::IsFootnoteFrame() const
1181{
  return mnFrameType == SwFrameType::Ftn;
1183}
1184inline bool SwFrame::IsBodyFrame() const
1185{
  return mnFrameType == SwFrameType::Body;
1187}
1188inline bool SwFrame::IsFlyFrame() const
1189{
  return mnFrameType == SwFrameType::Fly;
1191}
1192inline bool SwFrame::IsSctFrame() const
1193{
  return mnFrameType == SwFrameType::Section;
1195}
1196inline bool SwFrame::IsTabFrame() const
1197{
  return mnFrameType == SwFrameType::Tab;
1199}
1200inline bool SwFrame::IsRowFrame() const
1201{
  return mnFrameType == SwFrameType::Row;
1203}
1204inline bool SwFrame::IsCellFrame() const
1205{
  return mnFrameType == SwFrameType::Cell;
1207}
1208inline bool SwFrame::IsContentFrame() const
1209{
  return bool(GetType() & FRM_CNTNT(SwFrameType::Txt | SwFrameType::NoTxt));
1211}
1212inline bool SwFrame::IsTextFrame() const
1213{
  return mnFrameType == SwFrameType::Txt;
1215}
1216inline bool SwFrame::IsNoTextFrame() const
1217{
  return mnFrameType == SwFrameType::NoTxt;
1219}
1220inline bool SwFrame::IsFlowFrame() const
1221{
  return bool(GetType() & (FRM_CNTNT(SwFrameType::Txt | SwFrameType::NoTxt)|SwFrameType::Tab|SwFrameType::Section));
1223}
1224inline bool SwFrame::IsRetoucheFrame() const
1225{
  return bool(GetType() & (FRM_CNTNT(SwFrameType::Txt | SwFrameType::NoTxt)|SwFrameType::Tab|SwFrameType::Section|SwFrameType::Ftn));
1227}
1228inline bool SwFrame::IsAccessibleFrame() const
1229{
  return bool(GetType() & FRM_ACCESSIBLE(SwFrameType::Root | SwFrameType::Page | SwFrameType::Header |
 SwFrameType::Footer | SwFrameType::Ftn | SwFrameType::Fly | SwFrameType
::Tab | SwFrameType::Cell | SwFrameType::Txt));
1231}

1233//use this to protect a SwFrame for a given scope from getting deleted
1234class SwFrameDeleteGuard
1235{
1236private:
  SwFrame *m_pForbidFrame;
1238public:
  //Flag pFrame for SwFrameDeleteGuard lifetime that we shouldn't delete
  //it in e.g. SwSectionFrame::MergeNext etc because we will need it
  //again after the SwFrameDeleteGuard dtor
  explicit SwFrameDeleteGuard(SwFrame* pFrame)
      : m_pForbidFrame((pFrame && !pFrame->IsDeleteForbidden()) ?
          pFrame : nullptr)
  {
      if (m_pForbidFrame)
          m_pForbidFrame->ForbidDelete();
  }

  SwFrameDeleteGuard(const SwFrameDeleteGuard&) =delete;

  ~SwFrameDeleteGuard()
  {
      if (m_pForbidFrame)
          m_pForbidFrame->AllowDelete();
  }

  SwFrameDeleteGuard& operator=(const SwFrameDeleteGuard&) =delete;
1259};

1261typedef long (SwFrame::*SwFrameGet)() const;
1262typedef bool (SwFrame::*SwFrameMax)( long );
1263typedef void (SwFrame::*SwFrameMakePos)( const SwFrame*, const SwFrame*, bool );
1264typedef long (*SwOperator)( long, long );
1265typedef void (SwFrame::*SwFrameSet)( long, long );

1267struct SwRectFnCollection
1268{
  SwRectGet     fnGetTop;
  SwRectGet     fnGetBottom;
  SwRectGet     fnGetLeft;
  SwRectGet     fnGetRight;
  SwRectGet     fnGetWidth;
  SwRectGet     fnGetHeight;
  SwRectPoint   fnGetPos;
  SwRectSize    fnGetSize;

  SwRectSet     fnSetTop;
  SwRectSet     fnSetBottom;
  SwRectSet     fnSetLeft;
  SwRectSet     fnSetRight;
  SwRectSet     fnSetWidth;
  SwRectSet     fnSetHeight;

  SwRectSet     fnSubTop;
  SwRectSet     fnAddBottom;
  SwRectSet     fnSubLeft;
  SwRectSet     fnAddRight;
  SwRectSet     fnAddWidth;
  SwRectSet     fnAddHeight;

  SwRectSet     fnSetPosX;
  SwRectSet     fnSetPosY;

  SwFrameGet      fnGetTopMargin;
  SwFrameGet      fnGetBottomMargin;
  SwFrameGet      fnGetLeftMargin;
  SwFrameGet      fnGetRightMargin;
  SwFrameSet      fnSetXMargins;
  SwFrameSet      fnSetYMargins;
  SwFrameGet      fnGetPrtTop;
  SwFrameGet      fnGetPrtBottom;
  SwFrameGet      fnGetPrtLeft;
  SwFrameGet      fnGetPrtRight;
  SwRectDist      fnTopDist;
  SwRectDist      fnBottomDist;
  SwRectDist      fnLeftDist;
  SwRectDist      fnRightDist;
  SwFrameMax      fnSetLimit;
  SwRectMax       fnOverStep;

  SwRectSetPos    fnSetPos;
  SwFrameMakePos  fnMakePos;
  SwOperator      fnXDiff;
  SwOperator      fnYDiff;
  SwOperator      fnXInc;
  SwOperator      fnYInc;

  SwRectSetTwice  fnSetLeftAndWidth;
  SwRectSetTwice  fnSetTopAndHeight;
1321};

1323typedef SwRectFnCollection* SwRectFn;

1325// This class allows to use proper methods regardless of orientation (LTR/RTL, horizontal or vertical)
1326extern SwRectFn fnRectHori, fnRectVert, fnRectVertL2R, fnRectVertL2RB2T;
1327class SwRectFnSet {
1328public:
  explicit SwRectFnSet(const SwFrame *pFrame)
      : m_bVert(pFrame->IsVertical())
      , m_bVertL2R(pFrame->IsVertLR())
      , m_bVertL2RB2T(pFrame->IsVertLRBT())
  {
      m_fnRect = m_bVert ? (m_bVertL2R ? (m_bVertL2RB2T ? fnRectVertL2RB2T : fnRectVertL2R) : fnRectVert) : fnRectHori;
  }

  void Refresh(const SwFrame *pFrame)
  {
      m_bVert = pFrame->IsVertical();
      m_bVertL2R = pFrame->IsVertLR();
      m_bVertL2RB2T = pFrame->IsVertLRBT();
      m_fnRect = m_bVert ? (m_bVertL2R ? (m_bVertL2RB2T ? fnRectVertL2RB2T : fnRectVertL2R) : fnRectVert) : fnRectHori;
  }

  bool IsVert() const    { return m_bVert; }
  bool IsVertL2R() const { return m_bVertL2R; }
  SwRectFn FnRect() const { return m_fnRect; }

  bool PosDiff(const SwRect &rRect1, const SwRect &rRect2) const
  {
      return ((rRect1.*m_fnRect->fnGetTop)() != (rRect2.*m_fnRect->fnGetTop)()
          || (rRect1.*m_fnRect->fnGetLeft)() != (rRect2.*m_fnRect->fnGetLeft)());
  }

  long  GetTop   (const SwRect& rRect) const { return (rRect.*m_fnRect->fnGetTop)   (); }
  long  GetBottom(const SwRect& rRect) const { return (rRect.*m_fnRect->fnGetBottom)(); }
  long  GetLeft  (const SwRect& rRect) const { return (rRect.*m_fnRect->fnGetLeft)  (); }
  long  GetRight (const SwRect& rRect) const { return (rRect.*m_fnRect->fnGetRight) (); }
  long  GetWidth (const SwRect& rRect) const { return (rRect.*m_fnRect->fnGetWidth) (); }
  long  GetHeight(const SwRect& rRect) const { return (rRect.*m_fnRect->fnGetHeight)(); }
  Point GetPos   (const SwRect& rRect) const { return (rRect.*m_fnRect->fnGetPos)   (); }
  Size  GetSize  (const SwRect& rRect) const { return (rRect.*m_fnRect->fnGetSize)  (); }

  void SetTop   (SwRect& rRect, long nNew) const { (rRect.*m_fnRect->fnSetTop)   (nNew); }
  void SetBottom(SwRect& rRect, long nNew) const { (rRect.*m_fnRect->fnSetBottom)(nNew); }
  void SetLeft  (SwRect& rRect, long nNew) const { (rRect.*m_fnRect->fnSetLeft)  (nNew); }
  void SetRight (SwRect& rRect, long nNew) const { (rRect.*m_fnRect->fnSetRight) (nNew); }
  void SetWidth (SwRect& rRect, long nNew) const { (rRect.*m_fnRect->fnSetWidth) (nNew); }
  void SetHeight(SwRect& rRect, long nNew) const { (rRect.*m_fnRect->fnSetHeight)(nNew); }

  void SubTop   (SwRect& rRect, long nNew) const { (rRect.*m_fnRect->fnSubTop)   (nNew); }
  void AddBottom(SwRect& rRect, long nNew) const { (rRect.*m_fnRect->fnAddBottom)(nNew); }
  void SubLeft  (SwRect& rRect, long nNew) const { (rRect.*m_fnRect->fnSubLeft)  (nNew); }
  void AddRight (SwRect& rRect, long nNew) const { (rRect.*m_fnRect->fnAddRight) (nNew); }
  void AddWidth (SwRect& rRect, long nNew) const { (rRect.*m_fnRect->fnAddWidth) (nNew); }
  void AddHeight(SwRect& rRect, long nNew) const { (rRect.*m_fnRect->fnAddHeight)(nNew); }

  void SetPosX(SwRect& rRect, long nNew) const { (rRect.*m_fnRect->fnSetPosX)(nNew); }
  void SetPosY(SwRect& rRect, long nNew) const { (rRect.*m_fnRect->fnSetPosY)(nNew); }

  long  GetTopMargin   (const SwFrame& rFrame) const { return (rFrame.*m_fnRect->fnGetTopMargin)   (); }
  long  GetBottomMargin(const SwFrame& rFrame) const { return (rFrame.*m_fnRect->fnGetBottomMargin)(); }
  long  GetLeftMargin  (const SwFrame& rFrame) const { return (rFrame.*m_fnRect->fnGetLeftMargin)  (); }
  long  GetRightMargin (const SwFrame& rFrame) const { return (rFrame.*m_fnRect->fnGetRightMargin) (); }
  void  SetXMargins(SwFrame& rFrame, long nLeft, long nRight) const { (rFrame.*m_fnRect->fnSetXMargins)(nLeft, nRight); }
  void  SetYMargins(SwFrame& rFrame, long nTop, long nBottom) const { (rFrame.*m_fnRect->fnSetYMargins)(nTop, nBottom); }
  long  GetPrtTop      (const SwFrame& rFrame) const { return (rFrame.*m_fnRect->fnGetPrtTop)      (); }
  long  GetPrtBottom   (const SwFrame& rFrame) const { return (rFrame.*m_fnRect->fnGetPrtBottom)   (); }
  long  GetPrtLeft     (const SwFrame& rFrame) const { return (rFrame.*m_fnRect->fnGetPrtLeft)     (); }
  long  GetPrtRight    (const SwFrame& rFrame) const { return (rFrame.*m_fnRect->fnGetPrtRight)    (); }
  long  TopDist   (const SwRect& rRect, long nPos) const { return (rRect.*m_fnRect->fnTopDist)    (nPos); }
  long  BottomDist(const SwRect& rRect, long nPos) const { return (rRect.*m_fnRect->fnBottomDist) (nPos); }
  long  LeftDist   (const SwRect& rRect, long nPos) const { return (rRect.*m_fnRect->fnLeftDist)    (nPos); }
  long  RightDist   (const SwRect& rRect, long nPos) const { return (rRect.*m_fnRect->fnRightDist)    (nPos); }
  void  SetLimit (SwFrame& rFrame, long nNew) const { (rFrame.*m_fnRect->fnSetLimit) (nNew); }
  bool  OverStep  (const SwRect& rRect, long nPos) const { return (rRect.*m_fnRect->fnOverStep)   (nPos); }

  void SetPos(SwRect& rRect, const Point& rNew) const { (rRect.*m_fnRect->fnSetPos)(rNew); }
  void MakePos(SwFrame& rFrame, const SwFrame* pUp, const SwFrame* pPrv, bool bNotify) const { (rFrame.*m_fnRect->fnMakePos)(pUp, pPrv, bNotify); }
  long XDiff(long n1, long n2) const { return (m_fnRect->fnXDiff) (n1, n2); }
  long YDiff(long n1, long n2) const { return (m_fnRect->fnYDiff) (n1, n2); }
  long XInc (long n1, long n2) const { return (m_fnRect->fnXInc)  (n1, n2); }
  long YInc (long n1, long n2) const { return (m_fnRect->fnYInc)  (n1, n2); }

  void SetLeftAndWidth(SwRect& rRect, long nLeft, long nWidth) const { (rRect.*m_fnRect->fnSetLeftAndWidth)(nLeft, nWidth); }
  void SetTopAndHeight(SwRect& rRect, long nTop, long nHeight) const { (rRect.*m_fnRect->fnSetTopAndHeight)(nTop, nHeight); }

1408private:
  bool m_bVert;
  bool m_bVertL2R;
  bool m_bVertL2RB2T;
  SwRectFn m_fnRect;
1413};

1415#endif

1417/* vim:set shiftwidth=4 softtabstop=4 expandtab: */