/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx

Bug Summary

File:	home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx
Warning:	line 1213, column 1 Potential leak of memory pointed to by 'pLn'
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 untbl.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/undo/untbl.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 <UndoTable.hxx>
21#include <UndoRedline.hxx>
22#include <UndoDelete.hxx>
23#include <UndoSplitMove.hxx>
24#include <UndoCore.hxx>
25#include <fesh.hxx>
26#include <hintids.hxx>
27#include <hints.hxx>
28#include <doc.hxx>
29#include <docredln.hxx>
30#include <IDocumentUndoRedo.hxx>
31#include <IDocumentChartDataProviderAccess.hxx>
32#include <IDocumentRedlineAccess.hxx>
33#include <IDocumentFieldsAccess.hxx>
34#include <IDocumentStylePoolAccess.hxx>
35#include <editsh.hxx>
36#include <docary.hxx>
37#include <ndtxt.hxx>
38#include <swtable.hxx>
39#include <pam.hxx>
40#include <tblsel.hxx>
41#include <swundo.hxx>
42#include <rolbck.hxx>
43#include <ddefld.hxx>
44#include <tabfrm.hxx>
45#include <rowfrm.hxx>
46#include <cellfrm.hxx>
47#include <swcache.hxx>
48#include <tblafmt.hxx>
49#include <poolfmt.hxx>
50#include <mvsave.hxx>
51#include <cellatr.hxx>
52#include <swtblfmt.hxx>
53#include <swddetbl.hxx>
54#include <redline.hxx>
55#include <node2lay.hxx>
56#include <tblrwcl.hxx>
57#include <fmtanchr.hxx>
58#include <strings.hrc>
59#include <unochart.hxx>
60#include <calbck.hxx>
61#include <frameformats.hxx>

63#include <memory>
64#include <utility>
65#include <vector>

67#ifdef DBG_UTIL
68#define CHECK_TABLE(t) (t).CheckConsistency();
69#else
70#define CHECK_TABLE(t)
71#endif

73#ifdef DBG_UTIL
  #define DEBUG_REDLINE( pDoc ) sw_DebugRedline( pDoc );
75#else
  #define DEBUG_REDLINE( pDoc )
77#endif

79typedef std::vector<std::shared_ptr<SfxItemSet> > SfxItemSets;

81struct UndoTableCpyTable_Entry
82{
  sal_uLong nBoxIdx, nOffset;
  std::unique_ptr<SfxItemSet> pBoxNumAttr;
  std::unique_ptr<SwUndo> pUndo;

  // Was the last paragraph of the new and the first paragraph of the old content joined?
  bool bJoin; // For redlining only

  explicit UndoTableCpyTable_Entry( const SwTableBox& rBox );
91};

93namespace {

95class SaveBox;
96class SaveLine;

98}

100class SaveTable
101{
  friend SaveBox;
  friend SaveLine;
  SfxItemSet m_aTableSet;
  std::unique_ptr<SaveLine> m_pLine;
  const SwTable* m_pSwTable;
  SfxItemSets m_aSets;
  SwFrameFormatsV m_aFrameFormats;
  sal_uInt16 m_nLineCount;
  bool m_bModifyBox : 1;
  bool m_bSaveFormula : 1;
  bool m_bNewModel : 1;

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

117public:
  SaveTable( const SwTable& rTable, sal_uInt16 nLnCnt = USHRT_MAX(32767 *2 +1),
              bool bSaveFormula = true );

  sal_uInt16 AddFormat( SwFrameFormat* pFormat, bool bIsLine );
  void NewFrameFormat( const SwTableLine* , const SwTableBox*, sal_uInt16 nFormatPos,
                  SwFrameFormat* pOldFormat );

  void RestoreAttr( SwTable& rTable, bool bModifyBox = false );
  void SaveContentAttrs( SwDoc* pDoc );
  void CreateNew( SwTable& rTable, bool bCreateFrames = true,
                  bool bRestoreChart = true );
  bool IsNewModel() const { return m_bNewModel; }
130};

132namespace {

134class SaveLine
135{
  friend SaveTable;
  friend class SaveBox;

  SaveLine* pNext;
  SaveBox* pBox;
  sal_uInt16 nItemSet;

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

146public:
  SaveLine( SaveLine* pPrev, const SwTableLine& rLine, SaveTable& rSTable );
  ~SaveLine();

  void RestoreAttr( SwTableLine& rLine, SaveTable& rSTable );
  void SaveContentAttrs( SwDoc* pDoc );

  void CreateNew( SwTable& rTable, SwTableBox& rParent, SaveTable& rSTable  );
154};

156class SaveBox
157{
  friend class SaveLine;

  SaveBox* pNext;
  sal_uLong nSttNode;
  long nRowSpan;
  sal_uInt16 nItemSet;
  union
  {
      SfxItemSets* pContentAttrs;
      SaveLine* pLine;
  } Ptrs;

170public:
  SaveBox( SaveBox* pPrev, const SwTableBox& rBox, SaveTable& rSTable );
  ~SaveBox();

  void RestoreAttr( SwTableBox& rBox, SaveTable& rSTable );
  void SaveContentAttrs( SwDoc* pDoc );

  void CreateNew( SwTable& rTable, SwTableLine& rParent, SaveTable& rSTable );
178};

180}

182#if OSL_DEBUG_LEVEL1 > 0
183static void CheckTable( const SwTable& );
184#define CHECKTABLE(t)CheckTable( t ); CheckTable( t );
185#else
186#define CHECKTABLE(t)CheckTable( t );
187#endif

189/* #130880: Crash in undo of table to text when the table has (freshly) merged cells
190The order of cell content nodes in the nodes array is not given by the recursive table structure.
191The algorithm must not rely on this even it holds for a fresh loaded table in odt file format.
192So we need to remember not only the start node position but the end node position as well.
193*/

195struct SwTableToTextSave
196{
  sal_uLong m_nSttNd;
  sal_uLong m_nEndNd;
  sal_Int32 m_nContent;
  std::unique_ptr<SwHistory> m_pHstry;
  // metadata references for first and last paragraph in cell
  std::shared_ptr< ::sfx2::MetadatableUndo > m_pMetadataUndoStart;
  std::shared_ptr< ::sfx2::MetadatableUndo > m_pMetadataUndoEnd;

  SwTableToTextSave( SwDoc& rDoc, sal_uLong nNd, sal_uLong nEndIdx, sal_Int32 nContent );

207private:
  SwTableToTextSave(const SwTableToTextSave&) = delete;
  SwTableToTextSave& operator=(const SwTableToTextSave&) = delete;

211};

213sal_uInt16 const aSave_BoxContentSet[] = {
  RES_CHRATR_COLOR, RES_CHRATR_CROSSEDOUT,
  RES_CHRATR_FONT, RES_CHRATR_FONTSIZE,
  RES_CHRATR_POSTURE, RES_CHRATR_POSTURE,
  RES_CHRATR_SHADOWED, RES_CHRATR_WEIGHT,
  RES_PARATR_ADJUST, RES_PARATR_ADJUST,
  0 };

221SwUndoInsTable::SwUndoInsTable( const SwPosition& rPos, sal_uInt16 nCl, sal_uInt16 nRw,
                          sal_uInt16 nAdj, const SwInsertTableOptions& rInsTableOpts,
                          const SwTableAutoFormat* pTAFormat,
                          const std::vector<sal_uInt16> *pColArr,
                          const OUString & rName)
  : SwUndo( SwUndoId::INSTABLE, &rPos.GetDoc() ),
  m_aInsTableOptions( rInsTableOpts ),
  m_nStartNode( rPos.nNode.GetIndex() ), m_nRows( nRw ), m_nColumns( nCl ), m_nAdjust( nAdj )
229{
  if( pColArr )
  {
      m_pColumnWidth.reset( new std::vector<sal_uInt16>(*pColArr) );
  }
  if( pTAFormat )
      m_pAutoFormat.reset( new SwTableAutoFormat( *pTAFormat ) );

  // consider redline
  SwDoc& rDoc = rPos.nNode.GetNode().GetDoc();
  if( rDoc.getIDocumentRedlineAccess().IsRedlineOn() )
  {
      m_pRedlineData.reset( new SwRedlineData( RedlineType::Insert, rDoc.getIDocumentRedlineAccess().GetRedlineAuthor() ) );
      SetRedlineFlags( rDoc.getIDocumentRedlineAccess().GetRedlineFlags() );
  }

  m_sTableName = rName;
246}

248SwUndoInsTable::~SwUndoInsTable()
249{
  m_pDDEFieldType.reset();
  m_pColumnWidth.reset();
  m_pRedlineData.reset();
  m_pAutoFormat.reset();
254}

256void SwUndoInsTable::UndoImpl(::sw::UndoRedoContext & rContext)
257{
  SwDoc & rDoc = rContext.GetDoc();
  SwNodeIndex aIdx( rDoc.GetNodes(), m_nStartNode );

  SwTableNode* pTableNd = aIdx.GetNode().GetTableNode();
  OSL_ENSURE( pTableNd, "no TableNode" )do { if (true && (!(pTableNd))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "262" ": "), "%s", "no TableNode"); } } while (false);
  pTableNd->DelFrames();

  if( IDocumentRedlineAccess::IsRedlineOn( GetRedlineFlags() ))
      rDoc.getIDocumentRedlineAccess().DeleteRedline( *pTableNd, true, RedlineType::Any );
  RemoveIdxFromSection( rDoc, m_nStartNode );

  // move hard page breaks into next node
  SwContentNode* pNextNd = rDoc.GetNodes()[ pTableNd->EndOfSectionIndex()+1 ]->GetContentNode();
  if( pNextNd )
  {
      SwFrameFormat* pTableFormat = pTableNd->GetTable().GetFrameFormat();
      const SfxPoolItem *pItem;

      if( SfxItemState::SET == pTableFormat->GetItemState( RES_PAGEDESC,
          false, &pItem ) )
          pNextNd->SetAttr( *pItem );

      if( SfxItemState::SET == pTableFormat->GetItemState( RES_BREAK,
          false, &pItem ) )
          pNextNd->SetAttr( *pItem );
  }

  m_sTableName = pTableNd->GetTable().GetFrameFormat()->GetName();
  if( auto pDDETable = dynamic_cast<const SwDDETable *>(&pTableNd->GetTable()) )
      m_pDDEFieldType.reset(static_cast<SwDDEFieldType*>(pDDETable->GetDDEFieldType()->Copy().release()));

  rDoc.GetNodes().Delete( aIdx, pTableNd->EndOfSectionIndex() -
                              aIdx.GetIndex() + 1 );

  SwPaM & rPam( rContext.GetCursorSupplier().CreateNewShellCursor() );
  rPam.DeleteMark();
  rPam.GetPoint()->nNode = aIdx;
  rPam.GetPoint()->nContent.Assign( rPam.GetContentNode(), 0 );
296}

298void SwUndoInsTable::RedoImpl(::sw::UndoRedoContext & rContext)
299{
  SwDoc & rDoc = rContext.GetDoc();

  SwPosition const aPos(SwNodeIndex(rDoc.GetNodes(), m_nStartNode));
  const SwTable* pTable = rDoc.InsertTable( m_aInsTableOptions, aPos, m_nRows, m_nColumns,
                                          m_nAdjust,
                                          m_pAutoFormat.get(), m_pColumnWidth.get() );
  rDoc.GetEditShell()->MoveTable( GotoPrevTable, fnTableStart );
  static_cast<SwFrameFormat*>(pTable->GetFrameFormat())->SetName( m_sTableName );
  SwTableNode* pTableNode = rDoc.GetNodes()[m_nStartNode]->GetTableNode();

  if( m_pDDEFieldType )
  {
      SwDDEFieldType* pNewType = static_cast<SwDDEFieldType*>(rDoc.getIDocumentFieldsAccess().InsertFieldType(
                                                          *m_pDDEFieldType));
      std::unique_ptr<SwDDETable> pDDETable(new SwDDETable( pTableNode->GetTable(), pNewType ));
      pTableNode->SetNewTable( std::move(pDDETable) );
      m_pDDEFieldType.reset();
  }

  if( !((m_pRedlineData && IDocumentRedlineAccess::IsRedlineOn( GetRedlineFlags() )) ||
      ( !( RedlineFlags::Ignore & GetRedlineFlags() ) &&
          !rDoc.getIDocumentRedlineAccess().GetRedlineTable().empty() )))
      return;

  SwPaM aPam( *pTableNode->EndOfSectionNode(), *pTableNode, 1 );
  SwContentNode* pCNd = aPam.GetContentNode( false );
  if( pCNd )
      aPam.GetMark()->nContent.Assign( pCNd, 0 );

  if( m_pRedlineData && IDocumentRedlineAccess::IsRedlineOn( GetRedlineFlags() ) )
  {
      RedlineFlags eOld = rDoc.getIDocumentRedlineAccess().GetRedlineFlags();
      rDoc.getIDocumentRedlineAccess().SetRedlineFlags_intern(eOld & ~RedlineFlags::Ignore);

      rDoc.getIDocumentRedlineAccess().AppendRedline( new SwRangeRedline( *m_pRedlineData, aPam ), true);
      rDoc.getIDocumentRedlineAccess().SetRedlineFlags_intern( eOld );
  }
  else
      rDoc.getIDocumentRedlineAccess().SplitRedline( aPam );
339}

341void SwUndoInsTable::RepeatImpl(::sw::RepeatContext & rContext)
342{
  rContext.GetDoc().InsertTable(
          m_aInsTableOptions, *rContext.GetRepeatPaM().GetPoint(),
          m_nRows, m_nColumns, m_nAdjust, m_pAutoFormat.get(), m_pColumnWidth.get() );
346}

348SwRewriter SwUndoInsTable::GetRewriter() const
349{
  SwRewriter aRewriter;

  aRewriter.AddRule(UndoArg1, SwResId(STR_START_QUOTEreinterpret_cast<char const *>("STR_START_QUOTE" "\004"
 u8"“")));
  aRewriter.AddRule(UndoArg2, m_sTableName);
  aRewriter.AddRule(UndoArg3, SwResId(STR_END_QUOTEreinterpret_cast<char const *>("STR_END_QUOTE" "\004" u8"”"
)));

  return aRewriter;
357}

359SwTableToTextSave::SwTableToTextSave( SwDoc& rDoc, sal_uLong nNd, sal_uLong nEndIdx, sal_Int32 nCnt )
  : m_nSttNd( nNd ), m_nEndNd( nEndIdx), m_nContent( nCnt )
361{
  // keep attributes of the joined node
  SwTextNode* pNd = rDoc.GetNodes()[ nNd ]->GetTextNode();
  if( pNd )
  {
      m_pHstry.reset( new SwHistory );

      m_pHstry->Add( pNd->GetTextColl(), nNd, SwNodeType::Text );
      if ( pNd->GetpSwpHints() )
      {
          m_pHstry->CopyAttr( pNd->GetpSwpHints(), nNd, 0,
                      pNd->GetText().getLength(), false );
      }
      if( pNd->HasSwAttrSet() )
          m_pHstry->CopyFormatAttr( *pNd->GetpSwAttrSet(), nNd );

      if( !m_pHstry->Count() )
      {
          m_pHstry.reset();
      }

      // METADATA: store
      m_pMetadataUndoStart = pNd->CreateUndo();
  }

  // we also need to store the metadata reference of the _last_ paragraph
  // we subtract 1 to account for the removed cell start/end node pair
  // (after SectionUp, the end of the range points to the node after the cell)
  if ( nEndIdx - 1 > nNd )
  {
      SwTextNode* pLastNode( rDoc.GetNodes()[ nEndIdx - 1 ]->GetTextNode() );
      if( pLastNode )
      {
          // METADATA: store
          m_pMetadataUndoEnd = pLastNode->CreateUndo();
      }
  }
398}

400SwUndoTableToText::SwUndoTableToText( const SwTable& rTable, sal_Unicode cCh )
  : SwUndo( SwUndoId::TABLETOTEXT, rTable.GetFrameFormat()->GetDoc() ),
  m_sTableName( rTable.GetFrameFormat()->GetName() ),
  m_nStartNode( 0 ), m_nEndNode( 0 ),
  m_cSeparator( cCh ), m_nHeadlineRepeat( rTable.GetRowsToRepeat() )
405{
  m_pTableSave.reset( new SaveTable( rTable ) );
  m_vBoxSaves.reserve(rTable.GetTabSortBoxes().size());

  if( auto pDDETable = dynamic_cast<const SwDDETable *>(&rTable) )
      m_pDDEFieldType.reset(static_cast<SwDDEFieldType*>(pDDETable->GetDDEFieldType()->Copy().release()));

  m_bCheckNumFormat = rTable.GetFrameFormat()->GetDoc()->IsInsTableFormatNum();

  m_pHistory.reset(new SwHistory);
  const SwTableNode* pTableNd = rTable.GetTableNode();
  sal_uLong nTableStt = pTableNd->GetIndex(), nTableEnd = pTableNd->EndOfSectionIndex();

  const SwFrameFormats& rFrameFormatTable = *pTableNd->GetDoc().GetSpzFrameFormats();
  for( size_t n = 0; n < rFrameFormatTable.size(); ++n )
  {
      SwFrameFormat* pFormat = rFrameFormatTable[ n ];
      SwFormatAnchor const*const pAnchor = &pFormat->GetAnchor();
      SwPosition const*const pAPos = pAnchor->GetContentAnchor();
      if (pAPos &&
          ((RndStdIds::FLY_AT_CHAR == pAnchor->GetAnchorId()) ||
           (RndStdIds::FLY_AT_PARA == pAnchor->GetAnchorId())) &&
          nTableStt <= pAPos->nNode.GetIndex() &&
          pAPos->nNode.GetIndex() < nTableEnd )
      {
          m_pHistory->AddChangeFlyAnchor(*pFormat);
      }
  }

  if( !m_pHistory->Count() )
  {
      m_pHistory.reset();
  }
438}

440SwUndoTableToText::~SwUndoTableToText()
441{
  m_pDDEFieldType.reset();
  m_pTableSave.reset();
  m_vBoxSaves.clear();
  m_pHistory.reset();
446}

448void SwUndoTableToText::UndoImpl(::sw::UndoRedoContext & rContext)
449{
  SwDoc & rDoc = rContext.GetDoc();
  SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());

  SwNodeIndex aFrameIdx( rDoc.GetNodes(), m_nStartNode );
  SwNodeIndex aEndIdx( rDoc.GetNodes(), m_nEndNode );

  pPam->GetPoint()->nNode = aFrameIdx;
  pPam->SetMark();
  pPam->GetPoint()->nNode = aEndIdx;
  rDoc.DelNumRules( *pPam );
  pPam->DeleteMark();

  // now collect all Uppers
  SwNode2LayoutSaveUpperFrames aNode2Layout(aFrameIdx.GetNode());

  // create TableNode structure
  SwTableNode* pTableNd = rDoc.GetNodes().UndoTableToText( m_nStartNode, m_nEndNode, m_vBoxSaves );
  pTableNd->GetTable().SetTableModel( m_pTableSave->IsNewModel() );
  SwTableFormat* pTableFormat = rDoc.MakeTableFrameFormat( m_sTableName, rDoc.GetDfltFrameFormat() );
  pTableNd->GetTable().RegisterToFormat( *pTableFormat );
  pTableNd->GetTable().SetRowsToRepeat( m_nHeadlineRepeat );

  // create old table structure
  m_pTableSave->CreateNew( pTableNd->GetTable() );

  if( m_pDDEFieldType )
  {
      SwDDEFieldType* pNewType = static_cast<SwDDEFieldType*>(rDoc.getIDocumentFieldsAccess().InsertFieldType(
                                                          *m_pDDEFieldType));
      std::unique_ptr<SwDDETable> pDDETable( new SwDDETable( pTableNd->GetTable(), pNewType ) );
      pTableNd->SetNewTable( std::move(pDDETable), false );
      m_pDDEFieldType.reset();
  }

  if( m_bCheckNumFormat )
  {
      SwTableSortBoxes& rBxs = pTableNd->GetTable().GetTabSortBoxes();
      for (size_t nBoxes = rBxs.size(); nBoxes; )
      {
          rDoc.ChkBoxNumFormat( *rBxs[ --nBoxes ], false );
      }
  }

  if( m_pHistory )
  {
      sal_uInt16 nTmpEnd = m_pHistory->GetTmpEnd();
      m_pHistory->TmpRollback( &rDoc, 0 );
      m_pHistory->SetTmpEnd( nTmpEnd );
  }

  aNode2Layout.RestoreUpperFrames( rDoc.GetNodes(),
                                 pTableNd->GetIndex(), pTableNd->GetIndex()+1 );

  // Is a table selection requested?
  pPam->DeleteMark();
  pPam->GetPoint()->nNode = *pTableNd->EndOfSectionNode();
  pPam->SetMark();
  pPam->GetPoint()->nNode = *pPam->GetNode().StartOfSectionNode();
  pPam->Move( fnMoveForward, GoInContent );
  pPam->Exchange();
  pPam->Move( fnMoveBackward, GoInContent );

  ClearFEShellTabCols(rDoc, nullptr);
513}

515// located in untbl.cxx and only an Undo object is allowed to call it
516SwTableNode* SwNodes::UndoTableToText( sal_uLong nSttNd, sal_uLong nEndNd,
                              const SwTableToTextSaves& rSavedData )
518{
  SwNodeIndex aSttIdx( *this, nSttNd );
  SwNodeIndex aEndIdx( *this, nEndNd+1 );

  SwTableNode * pTableNd = new SwTableNode( aSttIdx );
  SwEndNode* pEndNd = new SwEndNode( aEndIdx, *pTableNd  );

  aEndIdx = *pEndNd;

  /* Set pTableNd as start of section for all nodes in [nSttNd, nEndNd].
     Delete all Frames attached to the nodes in that range. */
  SwNode* pNd;
  {
      sal_uLong n, nTmpEnd = aEndIdx.GetIndex();
      for( n = pTableNd->GetIndex() + 1; n < nTmpEnd; ++n )
      {
          if( ( pNd = (*this)[ n ] )->IsContentNode() )
              static_cast<SwContentNode*>(pNd)->DelFrames(nullptr);
          pNd->m_pStartOfSection = pTableNd;
      }
  }

  // than create table structure partially. First a single line that contains
  // all boxes. The correct structure is then taken from SaveStruct.
  SwTableBoxFormat* pBoxFormat = GetDoc().MakeTableBoxFormat();
  SwTableLineFormat* pLineFormat = GetDoc().MakeTableLineFormat();
  SwTableLine* pLine = new SwTableLine( pLineFormat, rSavedData.size(), nullptr );
  pTableNd->GetTable().GetTabLines().insert( pTableNd->GetTable().GetTabLines().begin(), pLine );

  const std::shared_ptr<sw::mark::ContentIdxStore> pContentStore(sw::mark::ContentIdxStore::Create());
  for( size_t n = rSavedData.size(); n; )
  {
      const SwTableToTextSave *const pSave = rSavedData[ --n ].get();
      // if the start node was merged with last from prev. cell,
      // subtract 1 from index to get the merged paragraph, and split that
      aSttIdx = pSave->m_nSttNd - ( ( SAL_MAX_INT32((sal_Int32) 0x7FFFFFFF) != pSave->m_nContent ) ? 1 : 0);
      SwTextNode* pTextNd = aSttIdx.GetNode().GetTextNode();

      if( SAL_MAX_INT32((sal_Int32) 0x7FFFFFFF) != pSave->m_nContent )
      {
          // split at ContentPosition, delete previous char (= separator)
          OSL_ENSURE( pTextNd, "Where is my TextNode?" )do { if (true && (!(pTextNd))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "559" ": "), "%s", "Where is my TextNode?"); } } while (
false);
          SwIndex aCntPos( pTextNd, pSave->m_nContent - 1 );

          pTextNd->EraseText( aCntPos, 1 );

          std::function<void (SwTextNode *, sw::mark::RestoreMode)> restoreFunc(
              [&](SwTextNode *const pNewNode, sw::mark::RestoreMode const eMode)
              {
                  if (!pContentStore->Empty())
                  {
                      pContentStore->Restore(*pNewNode, pSave->m_nContent, pSave->m_nContent + 1, eMode);
                  }
              });
          pTextNd->SplitContentNode(
                      SwPosition(aSttIdx, aCntPos), &restoreFunc);
      }
      else
      {
          pContentStore->Clear();
          if( pTextNd )
          {
              pContentStore->Save(GetDoc(), aSttIdx.GetIndex(), SAL_MAX_INT32((sal_Int32) 0x7FFFFFFF));
          }
      }

      if( pTextNd )
      {
          // METADATA: restore
          pTextNd->GetTextNode()->RestoreMetadata(pSave->m_pMetadataUndoStart);
          if( pTextNd->HasSwAttrSet() )
              pTextNd->ResetAllAttr();

          if( pTextNd->GetpSwpHints() )
              pTextNd->ClearSwpHintsArr( false );
      }

      if( pSave->m_pHstry )
      {
          sal_uInt16 nTmpEnd = pSave->m_pHstry->GetTmpEnd();
          pSave->m_pHstry->TmpRollback( &GetDoc(), 0 );
          pSave->m_pHstry->SetTmpEnd( nTmpEnd );
      }

      // METADATA: restore
      // end points to node after cell
      if ( pSave->m_nEndNd - 1 > pSave->m_nSttNd )
      {
          SwTextNode* pLastNode = (*this)[ pSave->m_nEndNd - 1 ]->GetTextNode();
          if (pLastNode)
          {
              pLastNode->RestoreMetadata(pSave->m_pMetadataUndoEnd);
          }
      }

      aEndIdx = pSave->m_nEndNd;
      SwStartNode* pSttNd = new SwStartNode( aSttIdx, SwNodeType::Start,
                                              SwTableBoxStartNode );
      pSttNd->m_pStartOfSection = pTableNd;
      new SwEndNode( aEndIdx, *pSttNd );

      for( sal_uLong i = aSttIdx.GetIndex(); i < aEndIdx.GetIndex()-1; ++i )
      {
          pNd = (*this)[ i ];
          pNd->m_pStartOfSection = pSttNd;
          if( pNd->IsStartNode() )
              i = pNd->EndOfSectionIndex();
      }

      SwTableBox* pBox = new SwTableBox( pBoxFormat, *pSttNd, pLine );
      pLine->GetTabBoxes().insert( pLine->GetTabBoxes().begin(), pBox );
  }
  return pTableNd;
631}

633void SwUndoTableToText::RedoImpl(::sw::UndoRedoContext & rContext)
634{
  SwDoc & rDoc = rContext.GetDoc();
  SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());

  pPam->GetPoint()->nNode = m_nStartNode;
  pPam->GetPoint()->nContent.Assign( nullptr, 0 );
  SwNodeIndex aSaveIdx( pPam->GetPoint()->nNode, -1 );

  pPam->SetMark();            // log off all indices
  pPam->DeleteMark();

  SwTableNode* pTableNd = pPam->GetNode().GetTableNode();
  OSL_ENSURE( pTableNd, "Could not find any TableNode" )do { if (true && (!(pTableNd))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "646" ": "), "%s", "Could not find any TableNode"); } } while
 (false);

  if( auto pDDETable = dynamic_cast<const SwDDETable *>(&pTableNd->GetTable()) )
      m_pDDEFieldType.reset(static_cast<SwDDEFieldType*>(pDDETable->GetDDEFieldType()->Copy().release()));

  rDoc.TableToText( pTableNd, m_cSeparator );

  ++aSaveIdx;
  SwContentNode* pCNd = aSaveIdx.GetNode().GetContentNode();
  if( !pCNd && nullptr == ( pCNd = rDoc.GetNodes().GoNext( &aSaveIdx ) ) &&
      nullptr == ( pCNd = SwNodes::GoPrevious( &aSaveIdx )) )
  {
      OSL_FAIL( "Where is the TextNode now?" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "658" ": "), "%s", "Where is the TextNode now?"); } } while
 (false);
  }

  pPam->GetPoint()->nNode = aSaveIdx;
  pPam->GetPoint()->nContent.Assign( pCNd, 0 );

  pPam->SetMark();            // log off all indices
  pPam->DeleteMark();
666}

668void SwUndoTableToText::RepeatImpl(::sw::RepeatContext & rContext)
669{
  SwPaM *const pPam = & rContext.GetRepeatPaM();
  SwTableNode *const pTableNd = pPam->GetNode().FindTableNode();
  if( pTableNd )
  {
      // move cursor out of table
      pPam->GetPoint()->nNode = *pTableNd->EndOfSectionNode();
      pPam->Move( fnMoveForward, GoInContent );
      pPam->SetMark();
      pPam->DeleteMark();

      rContext.GetDoc().TableToText( pTableNd, m_cSeparator );
  }
682}

684void SwUndoTableToText::SetRange( const SwNodeRange& rRg )
685{
  m_nStartNode = rRg.aStart.GetIndex();
  m_nEndNode = rRg.aEnd.GetIndex();
688}

690void SwUndoTableToText::AddBoxPos( SwDoc& rDoc, sal_uLong nNdIdx, sal_uLong nEndIdx, sal_Int32 nContentIdx )
691{
  m_vBoxSaves.push_back(std::make_unique<SwTableToTextSave>(rDoc, nNdIdx, nEndIdx, nContentIdx));
693}

695SwUndoTextToTable::SwUndoTextToTable( const SwPaM& rRg,
                              const SwInsertTableOptions& rInsTableOpts,
                              sal_Unicode cCh, sal_uInt16 nAdj,
                              const SwTableAutoFormat* pAFormat )
  : SwUndo( SwUndoId::TEXTTOTABLE, &rRg.GetDoc() ), SwUndRng( rRg ), m_aInsertTableOpts( rInsTableOpts ),
    m_pHistory( nullptr ), m_cSeparator( cCh ), m_nAdjust( nAdj )
701{
  if( pAFormat )
      m_pAutoFormat.reset( new SwTableAutoFormat( *pAFormat ) );

  const SwPosition* pEnd = rRg.End();
  SwNodes& rNds = rRg.GetDoc().GetNodes();
  m_bSplitEnd = pEnd->nContent.GetIndex() && ( pEnd->nContent.GetIndex()
                      != pEnd->nNode.GetNode().GetContentNode()->Len() ||
              pEnd->nNode.GetIndex() >= rNds.GetEndOfContent().GetIndex()-1 );
710}

712SwUndoTextToTable::~SwUndoTextToTable()
713{
  m_pAutoFormat.reset();
715}

717void SwUndoTextToTable::UndoImpl(::sw::UndoRedoContext & rContext)
718{
  SwDoc & rDoc = rContext.GetDoc();

  sal_uLong nTableNd = m_nSttNode;
  if( m_nSttContent )
      ++nTableNd;       // Node was split previously
  SwNodeIndex aIdx( rDoc.GetNodes(), nTableNd );
  SwTableNode *const pTNd = aIdx.GetNode().GetTableNode();
  OSL_ENSURE( pTNd, "Could not find a TableNode" )do { if (true && (!(pTNd))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "726" ": "), "%s", "Could not find a TableNode"); } } while
 (false);

  RemoveIdxFromSection( rDoc, nTableNd );

  m_sTableName = pTNd->GetTable().GetFrameFormat()->GetName();

  if( m_pHistory )
  {
      m_pHistory->TmpRollback( &rDoc, 0 );
      m_pHistory->SetTmpEnd( m_pHistory->Count() );
  }

  if( !mvDelBoxes.empty() )
  {
      pTNd->DelFrames();
      SwTable& rTable = pTNd->GetTable();
      for( size_t n = mvDelBoxes.size(); n; )
      {
          SwTableBox* pBox = rTable.GetTableBox( mvDelBoxes[ --n ] );
          if( pBox )
              ::DeleteBox_( rTable, pBox, nullptr, false, false );
          else {
              OSL_ENSURE( false, "Where is my box?" )do { if (true && (!(false))) { sal_detail_logFormat((
SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "748" ": "), "%s", "Where is my box?"); } } while (false
);
          }
      }
  }

  rDoc.TableToText( pTNd, 0x0b == m_cSeparator ? 0x09 : m_cSeparator );

  // join again at start?
  SwPaM aPam(rDoc.GetNodes().GetEndOfContent());
  SwPosition *const pPos = aPam.GetPoint();
  if( m_nSttContent )
  {
      pPos->nNode = nTableNd;
      pPos->nContent.Assign(pPos->nNode.GetNode().GetContentNode(), 0);
      if (aPam.Move(fnMoveBackward, GoInContent))
      {
          SwNodeIndex & rIdx = aPam.GetPoint()->nNode;

          // than move, relatively, the Cursor/etc. again
          RemoveIdxRel( rIdx.GetIndex()+1, *pPos );

          rIdx.GetNode().GetContentNode()->JoinNext();
      }
  }

  // join again at end?
  if( m_bSplitEnd )
  {
      SwNodeIndex& rIdx = pPos->nNode;
      rIdx = m_nEndNode;
      SwTextNode* pTextNd = rIdx.GetNode().GetTextNode();
      if( pTextNd && pTextNd->CanJoinNext() )
      {
          aPam.GetMark()->nContent.Assign( nullptr, 0 );
          aPam.GetPoint()->nContent.Assign( nullptr, 0 );

          // than move, relatively, the Cursor/etc. again
          pPos->nContent.Assign(pTextNd, pTextNd->GetText().getLength());
          RemoveIdxRel( m_nEndNode + 1, *pPos );

          pTextNd->JoinNext();
      }
  }

  AddUndoRedoPaM(rContext);
793}

795void SwUndoTextToTable::RedoImpl(::sw::UndoRedoContext & rContext)
796{
  SwPaM & rPam( AddUndoRedoPaM(rContext) );
  RemoveIdxFromRange(rPam, false);
  SetPaM(rPam);

  SwTable const*const pTable = rContext.GetDoc().TextToTable(
              m_aInsertTableOpts, rPam, m_cSeparator, m_nAdjust, m_pAutoFormat.get() );
  static_cast<SwFrameFormat*>(pTable->GetFrameFormat())->SetName( m_sTableName );
804}

806void SwUndoTextToTable::RepeatImpl(::sw::RepeatContext & rContext)
807{
  // no Table In Table
  if (!rContext.GetRepeatPaM().GetNode().FindTableNode())
  {
      rContext.GetDoc().TextToTable( m_aInsertTableOpts, rContext.GetRepeatPaM(),
                                      m_cSeparator, m_nAdjust,
                                      m_pAutoFormat.get() );
  }
815}

817void SwUndoTextToTable::AddFillBox( const SwTableBox& rBox )
818{
  mvDelBoxes.push_back( rBox.GetSttIdx() );
820}

822SwHistory& SwUndoTextToTable::GetHistory()
823{
  if( !m_pHistory )
      m_pHistory = new SwHistory;
  return *m_pHistory;
827}

829SwUndoTableHeadline::SwUndoTableHeadline( const SwTable& rTable, sal_uInt16 nOldHdl,
                                    sal_uInt16 nNewHdl )
  : SwUndo( SwUndoId::TABLEHEADLINE, rTable.GetFrameFormat()->GetDoc() ),
  m_nOldHeadline( nOldHdl ),
  m_nNewHeadline( nNewHdl )
834{
  OSL_ENSURE( !rTable.GetTabSortBoxes().empty(), "Table without content" )do { if (true && (!(!rTable.GetTabSortBoxes().empty()
))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "835" ": "), "%s", "Table without content"); } } while (
false);
  const SwStartNode *pSttNd = rTable.GetTabSortBoxes()[ 0 ]->GetSttNd();
  OSL_ENSURE( pSttNd, "Box without content" )do { if (true && (!(pSttNd))) { sal_detail_logFormat(
(SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "837" ": "), "%s", "Box without content"); } } while (false
);

  m_nTableNode = pSttNd->StartOfSectionIndex();
840}

842void SwUndoTableHeadline::UndoImpl(::sw::UndoRedoContext & rContext)
843{
  SwDoc & rDoc = rContext.GetDoc();
  SwTableNode* pTNd = rDoc.GetNodes()[ m_nTableNode ]->GetTableNode();
  OSL_ENSURE( pTNd, "could not find any TableNode" )do { if (true && (!(pTNd))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "846" ": "), "%s", "could not find any TableNode"); } } while
 (false);

  rDoc.SetRowsToRepeat( pTNd->GetTable(), m_nOldHeadline );
849}

851void SwUndoTableHeadline::RedoImpl(::sw::UndoRedoContext & rContext)
852{
  SwDoc & rDoc = rContext.GetDoc();

  SwTableNode* pTNd = rDoc.GetNodes()[ m_nTableNode ]->GetTableNode();
  OSL_ENSURE( pTNd, "could not find any TableNode" )do { if (true && (!(pTNd))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "856" ": "), "%s", "could not find any TableNode"); } } while
 (false);

  rDoc.SetRowsToRepeat( pTNd->GetTable(), m_nNewHeadline );
859}

861void SwUndoTableHeadline::RepeatImpl(::sw::RepeatContext & rContext)
862{
  SwTableNode *const pTableNd =
      rContext.GetRepeatPaM().GetNode().FindTableNode();
  if( pTableNd )
  {
      rContext.GetDoc().SetRowsToRepeat( pTableNd->GetTable(), m_nNewHeadline );
  }
869}

871SaveTable::SaveTable( const SwTable& rTable, sal_uInt16 nLnCnt, bool bSaveFormula )
  : m_aTableSet(*rTable.GetFrameFormat()->GetAttrSet().GetPool(), aTableSetRange),
    m_pSwTable(&rTable), m_nLineCount(nLnCnt), m_bSaveFormula(bSaveFormula)
874{
  m_bModifyBox = false;
  m_bNewModel = rTable.IsNewModel();
  m_aTableSet.Put(rTable.GetFrameFormat()->GetAttrSet());
  m_pLine.reset( new SaveLine( nullptr, *rTable.GetTabLines()[ 0 ], *this ) );
4
←
Calling constructor for 'SaveLine'→

  SaveLine* pLn = m_pLine.get();
  if( USHRT_MAX(32767 *2 +1) == nLnCnt )
      nLnCnt = rTable.GetTabLines().size();
  for( sal_uInt16 n = 1; n < nLnCnt; ++n )
      pLn = new SaveLine( pLn, *rTable.GetTabLines()[ n ], *this );

  m_aFrameFormats.clear();
  m_pSwTable = nullptr;
888}

890sal_uInt16 SaveTable::AddFormat( SwFrameFormat* pFormat, bool bIsLine )
891{
  size_t nRet = m_aFrameFormats.GetPos(pFormat);
  if( SIZE_MAX(18446744073709551615UL) == nRet )
  {
      // Create copy of ItemSet
      auto pSet = std::make_shared<SfxItemSet>( *pFormat->GetAttrSet().GetPool(),
          bIsLine ? aTableLineSetRange : aTableBoxSetRange );
      pSet->Put( pFormat->GetAttrSet() );
      // When a formula is set, never save the value. It possibly must be
      // recalculated.
      // Save formulas always in plain text.
      const SfxPoolItem* pItem;
      if( SfxItemState::SET == pSet->GetItemState( RES_BOXATR_FORMULA, true, &pItem ))
      {
          pSet->ClearItem( RES_BOXATR_VALUE );
          if (m_pSwTable && m_bSaveFormula)
          {
              SwTableFormulaUpdate aMsgHint(m_pSwTable);
              aMsgHint.m_eFlags = TBL_BOXNAME;
              SwTableBoxFormula* pFormulaItem = const_cast<SwTableBoxFormula*>(static_cast<const SwTableBoxFormula*>(pItem));
              pFormulaItem->ChgDefinedIn( pFormat );
              pFormulaItem->ChangeState( &aMsgHint );
              pFormulaItem->ChgDefinedIn( nullptr );
          }
      }
      nRet = m_aSets.size();
      m_aSets.push_back(pSet);
      m_aFrameFormats.insert(m_aFrameFormats.begin() + nRet, pFormat);
  }
  return static_cast<sal_uInt16>(nRet);
921}

923void SaveTable::RestoreAttr( SwTable& rTable, bool bMdfyBox )
924{
  m_bModifyBox = bMdfyBox;

  // first, get back attributes of TableFrameFormat
  SwFrameFormat* pFormat = rTable.GetFrameFormat();
  SfxItemSet& rFormatSet  = const_cast<SfxItemSet&>(static_cast<SfxItemSet const &>(pFormat->GetAttrSet()));
  rFormatSet.ClearItem();
  rFormatSet.Put(m_aTableSet);

  if( pFormat->IsInCache() )
  {
      SwFrame::GetCache().Delete( pFormat );
      pFormat->SetInCache( false );
  }

  // for safety, invalidate all TableFrames
  SwIterator<SwTabFrame,SwFormat> aIter( *pFormat );
  for( SwTabFrame* pLast = aIter.First(); pLast; pLast = aIter.Next() )
      if( pLast->GetTable() == &rTable )
      {
          pLast->InvalidateAll();
          pLast->SetCompletePaint();
      }

  // fill FrameFormats with defaults (0)
  pFormat = nullptr;
  for (size_t n = m_aSets.size(); n; --n)
      m_aFrameFormats.push_back(pFormat);

  const size_t nLnCnt = (USHRT_MAX(32767 *2 +1) == m_nLineCount)
      ? rTable.GetTabLines().size()
      : m_nLineCount;

  SaveLine* pLn = m_pLine.get();
  for( size_t n = 0; n < nLnCnt; ++n, pLn = pLn->pNext )
  {
      if( !pLn )
      {
          OSL_ENSURE( false, "Number of lines changed" )do { if (true && (!(false))) { sal_detail_logFormat((
SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "962" ": "), "%s", "Number of lines changed"); } } while
 (false);
          break;
      }

      pLn->RestoreAttr( *rTable.GetTabLines()[ n ], *this );
  }

  m_aFrameFormats.clear();
  m_bModifyBox = false;
971}

973void SaveTable::SaveContentAttrs( SwDoc* pDoc )
974{
  m_pLine->SaveContentAttrs(pDoc);
976}

978void SaveTable::CreateNew( SwTable& rTable, bool bCreateFrames,
                          bool bRestoreChart )
980{
  FndBox_ aTmpBox( nullptr, nullptr );
  aTmpBox.DelFrames( rTable );

  // first, get back attributes of TableFrameFormat
  SwFrameFormat* pFormat = rTable.GetFrameFormat();
  SfxItemSet& rFormatSet  = const_cast<SfxItemSet&>(static_cast<SfxItemSet const &>(pFormat->GetAttrSet()));
  rFormatSet.ClearItem();
  rFormatSet.Put(m_aTableSet);

  if( pFormat->IsInCache() )
  {
      SwFrame::GetCache().Delete( pFormat );
      pFormat->SetInCache( false );
  }

  // SwTableBox must have a format - the SwTableBox takes ownership of it
  SwTableBoxFormat *const pNewFormat(pFormat->GetDoc()->MakeTableBoxFormat());
  SwTableBox aParent(pNewFormat, rTable.GetTabLines().size(), nullptr);

  // fill FrameFormats with defaults (0)
  pFormat = nullptr;
  for( size_t n = m_aSets.size(); n; --n )
      m_aFrameFormats.push_back(pFormat);

  m_pLine->CreateNew(rTable, aParent, *this);
  m_aFrameFormats.clear();

  // add new lines, delete old ones
  const size_t nOldLines = (USHRT_MAX(32767 *2 +1) == m_nLineCount)
      ? rTable.GetTabLines().size()
      : m_nLineCount;

  SwDoc *pDoc = rTable.GetFrameFormat()->GetDoc();
  SwChartDataProvider *pPCD = pDoc->getIDocumentChartDataProviderAccess().GetChartDataProvider();
  size_t n = 0;
  for( ; n < aParent.GetTabLines().size(); ++n )
  {
      SwTableLine* pLn = aParent.GetTabLines()[ n ];
      pLn->SetUpper( nullptr );
      if( n < nOldLines )
      {
          SwTableLine* pOld = rTable.GetTabLines()[ n ];

          // TL_CHART2: notify chart about boxes to be removed
          const SwTableBoxes &rBoxes = pOld->GetTabBoxes();
          const size_t nBoxes = rBoxes.size();
          for (size_t k = 0; k < nBoxes;  ++k)
          {
              SwTableBox *pBox = rBoxes[k];
              if (pPCD)
                  pPCD->DeleteBox( &rTable, *pBox );
          }

          rTable.GetTabLines()[n] = pLn;
          delete pOld;
      }
      else
          rTable.GetTabLines().insert( rTable.GetTabLines().begin() + n, pLn );
  }

  if( n < nOldLines )
  {
      // remove remaining lines...
      for (size_t k1 = 0; k1 < nOldLines - n; ++k1)
      {
          const SwTableBoxes &rBoxes = rTable.GetTabLines()[n + k1]->GetTabBoxes();
          const size_t nBoxes = rBoxes.size();
          for (size_t k2 = 0; k2 < nBoxes; ++k2)
          {
              SwTableBox *pBox = rBoxes[k2];
              // TL_CHART2: notify chart about boxes to be removed
              if (pPCD)
                  pPCD->DeleteBox( &rTable, *pBox );
          }
      }

      for( SwTableLines::const_iterator it = rTable.GetTabLines().begin() + n;
           it != rTable.GetTabLines().begin() + nOldLines; ++it )
          delete *it;
      rTable.GetTabLines().erase( rTable.GetTabLines().begin() + n, rTable.GetTabLines().begin() + nOldLines );
  }

  aParent.GetTabLines().erase( aParent.GetTabLines().begin(), aParent.GetTabLines().begin() + n );
  assert(aParent.GetTabLines().empty())(static_cast <bool> (aParent.GetTabLines().empty()) ? void
 (0) : __assert_fail ("aParent.GetTabLines().empty()", "/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
, 1064, __extension__ __PRETTY_FUNCTION__));

  if( bCreateFrames )
      aTmpBox.MakeFrames( rTable );
  if( bRestoreChart )
  {
      // TL_CHART2: need to inform chart of probably changed cell names
      pDoc->UpdateCharts( rTable.GetFrameFormat()->GetName() );
  }
1073}

1075void SaveTable::NewFrameFormat( const SwTableLine* pTableLn, const SwTableBox* pTableBx,
                          sal_uInt16 nFormatPos, SwFrameFormat* pOldFormat )
1077{
  SwDoc* pDoc = pOldFormat->GetDoc();

  SwFrameFormat* pFormat = m_aFrameFormats[ nFormatPos ];
  if( !pFormat )
  {
      if( pTableLn )
          pFormat = pDoc->MakeTableLineFormat();
      else
          pFormat = pDoc->MakeTableBoxFormat();
      pFormat->SetFormatAttr(*m_aSets[nFormatPos]);
      m_aFrameFormats[nFormatPos] = pFormat;
  }

  // first re-assign Frames
  SwIterator<SwLayoutFrame,SwFormat> aIter( *pOldFormat );
  for( SwFrame* pLast = aIter.First(); pLast; pLast = aIter.Next() )
  {
      if( pTableLn ? static_cast<SwRowFrame*>(pLast)->GetTabLine() == pTableLn
                  : static_cast<SwCellFrame*>(pLast)->GetTabBox() == pTableBx )
      {
          pLast->RegisterToFormat(*pFormat);
          pLast->InvalidateAll();
          pLast->ReinitializeFrameSizeAttrFlags();
          if ( !pTableLn )
          {
              static_cast<SwCellFrame*>(pLast)->SetDerivedVert( false );
              static_cast<SwCellFrame*>(pLast)->CheckDirChange();
          }
      }
  }

  // than re-assign myself
  if ( pTableLn )
      const_cast<SwTableLine*>(pTableLn)->RegisterToFormat( *pFormat );
  else if ( pTableBx )
      const_cast<SwTableBox*>(pTableBx)->RegisterToFormat( *pFormat );

  if (m_bModifyBox && !pTableLn)
  {
      const SfxPoolItem& rOld = pOldFormat->GetFormatAttr( RES_BOXATR_FORMAT ),
                       & rNew = pFormat->GetFormatAttr( RES_BOXATR_FORMAT );
      if( rOld != rNew )
          pFormat->ModifyNotification( &rOld, &rNew );
  }

  if( !pOldFormat->HasWriterListeners() )
      delete pOldFormat;
1125}

1127SaveLine::SaveLine( SaveLine* pPrev, const SwTableLine& rLine, SaveTable& rSTable )
  : pNext( nullptr )
1129{
  if( pPrev4.1
'pPrev' is null
 )
5
←
Taking false branch→
      pPrev->pNext = this;

  nItemSet = rSTable.AddFormat( rLine.GetFrameFormat(), true );

  pBox = new SaveBox( nullptr, *rLine.GetTabBoxes()[ 0 ], rSTable );
6
←
Calling constructor for 'SaveBox'→
  SaveBox* pBx = pBox;
  for( size_t n = 1; n < rLine.GetTabBoxes().size(); ++n )
      pBx = new SaveBox( pBx, *rLine.GetTabBoxes()[ n ], rSTable );
1139}

1141SaveLine::~SaveLine()
1142{
  delete pBox;
  delete pNext;
1145}

1147void SaveLine::RestoreAttr( SwTableLine& rLine, SaveTable& rSTable )
1148{
  rSTable.NewFrameFormat( &rLine, nullptr, nItemSet, rLine.GetFrameFormat() );

  SaveBox* pBx = pBox;
  for( size_t n = 0; n < rLine.GetTabBoxes().size(); ++n, pBx = pBx->pNext )
  {
      if( !pBx )
      {
          OSL_ENSURE( false, "Number of boxes changed" )do { if (true && (!(false))) { sal_detail_logFormat((
SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "1156" ": "), "%s", "Number of boxes changed"); } } while
 (false);
          break;
      }
      pBx->RestoreAttr( *rLine.GetTabBoxes()[ n ], rSTable );
  }
1161}

1163void SaveLine::SaveContentAttrs( SwDoc* pDoc )
1164{
  pBox->SaveContentAttrs( pDoc );
  if( pNext )
      pNext->SaveContentAttrs( pDoc );
1168}

1170void SaveLine::CreateNew( SwTable& rTable, SwTableBox& rParent, SaveTable& rSTable )
1171{
  SwTableLineFormat* pFormat = static_cast<SwTableLineFormat*>(rSTable.m_aFrameFormats[ nItemSet ]);
  if( !pFormat )
  {
      SwDoc* pDoc = rTable.GetFrameFormat()->GetDoc();
      pFormat = pDoc->MakeTableLineFormat();
      pFormat->SetFormatAttr(*rSTable.m_aSets[nItemSet]);
      rSTable.m_aFrameFormats[nItemSet] = pFormat;
  }
  SwTableLine* pNew = new SwTableLine( pFormat, 1, &rParent );

  rParent.GetTabLines().push_back( pNew );

  pBox->CreateNew( rTable, *pNew, rSTable );

  if( pNext )
      pNext->CreateNew( rTable, rParent, rSTable );
1188}

1190SaveBox::SaveBox( SaveBox* pPrev, const SwTableBox& rBox, SaveTable& rSTable )
  : pNext( nullptr ), nSttNode( ULONG_MAX(9223372036854775807L *2UL+1UL) ), nRowSpan(0)
1192{
  Ptrs.pLine = nullptr;

  if( pPrev6.1
'pPrev' is null
 )
7
←
Taking false branch→
      pPrev->pNext = this;

  nItemSet = rSTable.AddFormat( rBox.GetFrameFormat(), false );

  if( rBox.GetSttNd() )
8
←
Assuming the condition is false→
9
←
Taking false branch→
  {
      nSttNode = rBox.GetSttIdx();
      nRowSpan = rBox.getRowSpan();
  }
  else
  {
      Ptrs.pLine = new SaveLine( nullptr, *rBox.GetTabLines()[ 0 ], rSTable );

      SaveLine* pLn = Ptrs.pLine;
      for( size_t n = 1; n < rBox.GetTabLines().size(); ++n )
10
←
Assuming the condition is true→
11
←
Loop condition is true.  Entering loop body→
13
←
Assuming the condition is false→
14
←
Loop condition is false. Execution continues on line 1210→
          pLn = new SaveLine( pLn, *rBox.GetTabLines()[ n ], rSTable );
12
←
Memory is allocated→
  }
1213}
15
←
Potential leak of memory pointed to by 'pLn'

1215SaveBox::~SaveBox()
1216{
  if( ULONG_MAX(9223372036854775807L *2UL+1UL) == nSttNode )     // no EndBox
      delete Ptrs.pLine;
  else
      delete Ptrs.pContentAttrs;
  delete pNext;
1222}

1224void SaveBox::RestoreAttr( SwTableBox& rBox, SaveTable& rSTable )
1225{
  rSTable.NewFrameFormat( nullptr, &rBox, nItemSet, rBox.GetFrameFormat() );

  if( ULONG_MAX(9223372036854775807L *2UL+1UL) == nSttNode )     // no EndBox
  {
      if( rBox.GetTabLines().empty() )
      {
          OSL_ENSURE( false, "Number of lines changed" )do { if (true && (!(false))) { sal_detail_logFormat((
SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "1232" ": "), "%s", "Number of lines changed"); } } while
 (false);
      }
      else
      {
          SaveLine* pLn = Ptrs.pLine;
          for( size_t n = 0; n < rBox.GetTabLines().size(); ++n, pLn = pLn->pNext )
          {
              if( !pLn )
              {
                  OSL_ENSURE( false, "Number of lines changed" )do { if (true && (!(false))) { sal_detail_logFormat((
SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "1241" ": "), "%s", "Number of lines changed"); } } while
 (false);
                  break;
              }

              pLn->RestoreAttr( *rBox.GetTabLines()[ n ], rSTable );
          }
      }
  }
  else if( rBox.GetSttNd() && rBox.GetSttIdx() == nSttNode )
  {
      if( Ptrs.pContentAttrs )
      {
          SwNodes& rNds = rBox.GetFrameFormat()->GetDoc()->GetNodes();
          sal_uInt16 nSet = 0;
          sal_uLong nEnd = rBox.GetSttNd()->EndOfSectionIndex();
          for( sal_uLong n = nSttNode + 1; n < nEnd; ++n )
          {
              SwContentNode* pCNd = rNds[ n ]->GetContentNode();
              if( pCNd )
              {
                  std::shared_ptr<SfxItemSet> pSet( (*Ptrs.pContentAttrs)[ nSet++ ] );
                  if( pSet )
                  {
                      sal_uInt16 const *pRstAttr = aSave_BoxContentSet;
                      while( *pRstAttr )
                      {
                          pCNd->ResetAttr( *pRstAttr, *(pRstAttr+1) );
                          pRstAttr += 2;
                      }
                      pCNd->SetAttr( *pSet );
                  }
                  else
                      pCNd->ResetAllAttr();
              }
          }
      }
  }
  else
  {
      OSL_ENSURE( false, "Box not anymore at the same node" )do { if (true && (!(false))) { sal_detail_logFormat((
SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "1280" ": "), "%s", "Box not anymore at the same node");
 } } while (false);
  }
1282}

1284void SaveBox::SaveContentAttrs( SwDoc* pDoc )
1285{
  if( ULONG_MAX(9223372036854775807L *2UL+1UL) == nSttNode )     // no EndBox
  {
      // continue in current line
      Ptrs.pLine->SaveContentAttrs( pDoc );
  }
  else
  {
      sal_uLong nEnd = pDoc->GetNodes()[ nSttNode ]->EndOfSectionIndex();
      Ptrs.pContentAttrs = new SfxItemSets;
      for( sal_uLong n = nSttNode + 1; n < nEnd; ++n )
      {
          SwContentNode* pCNd = pDoc->GetNodes()[ n ]->GetContentNode();
          if( pCNd )
          {
              std::shared_ptr<SfxItemSet> pSet;
              if( pCNd->HasSwAttrSet() )
              {
                  pSet = std::make_shared<SfxItemSet>( pDoc->GetAttrPool(),
                                          aSave_BoxContentSet );
                  pSet->Put( *pCNd->GetpSwAttrSet() );
              }

              Ptrs.pContentAttrs->push_back( pSet );
          }
      }
  }
  if( pNext )
      pNext->SaveContentAttrs( pDoc );
1314}

1316void SaveBox::CreateNew( SwTable& rTable, SwTableLine& rParent, SaveTable& rSTable )
1317{
  SwTableBoxFormat* pFormat = static_cast<SwTableBoxFormat*>(rSTable.m_aFrameFormats[ nItemSet ]);
  if( !pFormat )
  {
      SwDoc* pDoc = rTable.GetFrameFormat()->GetDoc();
      pFormat = pDoc->MakeTableBoxFormat();
      pFormat->SetFormatAttr(*rSTable.m_aSets[nItemSet]);
      rSTable.m_aFrameFormats[nItemSet] = pFormat;
  }

  if( ULONG_MAX(9223372036854775807L *2UL+1UL) == nSttNode )     // no EndBox
  {
      SwTableBox* pNew = new SwTableBox( pFormat, 1, &rParent );
      rParent.GetTabBoxes().push_back( pNew );

      Ptrs.pLine->CreateNew( rTable, *pNew, rSTable );
  }
  else
  {
      // search box for StartNode in old table
      SwTableBox* pBox = rTable.GetTableBox( nSttNode );
      if (pBox)
      {
          SwFrameFormat* pOld = pBox->GetFrameFormat();
          pBox->RegisterToFormat( *pFormat );
          if( !pOld->HasWriterListeners() )
              delete pOld;

          pBox->setRowSpan( nRowSpan );

          SwTableBoxes* pTBoxes = &pBox->GetUpper()->GetTabBoxes();
          pTBoxes->erase( std::find( pTBoxes->begin(), pTBoxes->end(), pBox ) );

          pBox->SetUpper( &rParent );
          pTBoxes = &rParent.GetTabBoxes();
          pTBoxes->push_back( pBox );
      }
  }

  if( pNext )
      pNext->CreateNew( rTable, rParent, rSTable );
1358}

1360// UndoObject for attribute changes on table
1361SwUndoAttrTable::SwUndoAttrTable( const SwTableNode& rTableNd, bool bClearTabCols )
  : SwUndo( SwUndoId::TABLE_ATTR, &rTableNd.GetDoc() ),
  m_nStartNode( rTableNd.GetIndex() )
1364{
  m_bClearTableCol = bClearTabCols;
  m_pSaveTable.reset( new SaveTable( rTableNd.GetTable() ) );
1367}

1369SwUndoAttrTable::~SwUndoAttrTable()
1370{
1371}

1373void SwUndoAttrTable::UndoImpl(::sw::UndoRedoContext & rContext)
1374{
  SwDoc & rDoc = rContext.GetDoc();
  SwTableNode* pTableNd = rDoc.GetNodes()[ m_nStartNode ]->GetTableNode();
  OSL_ENSURE( pTableNd, "no TableNode" )do { if (true && (!(pTableNd))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "1377" ": "), "%s", "no TableNode"); } } while (false);

  if (pTableNd)
  {
      SaveTable* pOrig = new SaveTable( pTableNd->GetTable() );
      m_pSaveTable->RestoreAttr( pTableNd->GetTable() );
      m_pSaveTable.reset( pOrig );
  }

  if( m_bClearTableCol )
  {
      ClearFEShellTabCols(rDoc, nullptr);
  }
1390}

1392void SwUndoAttrTable::RedoImpl(::sw::UndoRedoContext & rContext)
1393{
  UndoImpl(rContext);
1395}

1397// UndoObject for AutoFormat on Table
1398SwUndoTableAutoFormat::SwUndoTableAutoFormat( const SwTableNode& rTableNd,
                                  const SwTableAutoFormat& rAFormat )
  : SwUndo( SwUndoId::TABLE_AUTOFMT, &rTableNd.GetDoc() )
  , m_TableStyleName(rTableNd.GetTable().GetTableStyleName())
  , m_nStartNode( rTableNd.GetIndex() )
  , m_bSaveContentAttr( false )
  , m_nRepeatHeading(rTableNd.GetTable().GetRowsToRepeat())
1405{
  m_pSaveTable.reset( new SaveTable( rTableNd.GetTable() ) );

  if( rAFormat.IsFont() || rAFormat.IsJustify() )
  {
      // then also go over the ContentNodes of the EndBoxes and collect
      // all paragraph attributes
      m_pSaveTable->SaveContentAttrs( &const_cast<SwDoc&>(rTableNd.GetDoc()) );
      m_bSaveContentAttr = true;
  }
1415}

1417SwUndoTableAutoFormat::~SwUndoTableAutoFormat()
1418{
1419}

1421void SwUndoTableAutoFormat::SaveBoxContent( const SwTableBox& rBox )
1422{
  m_Undos.push_back(std::make_shared<SwUndoTableNumFormat>(rBox));
1424}

1426void
1427SwUndoTableAutoFormat::UndoRedo(bool const bUndo, ::sw::UndoRedoContext & rContext)
1428{
  SwDoc & rDoc = rContext.GetDoc();
  SwTableNode* pTableNd = rDoc.GetNodes()[ m_nStartNode ]->GetTableNode();
  OSL_ENSURE( pTableNd, "no TableNode" )do { if (true && (!(pTableNd))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "1431" ": "), "%s", "no TableNode"); } } while (false);

  SwTable& table = pTableNd->GetTable();
  if (table.GetTableStyleName() != m_TableStyleName)
  {
      OUString const temp(table.GetTableStyleName());
      table.SetTableStyleName(m_TableStyleName);
      m_TableStyleName = temp;
  }
  SaveTable* pOrig = new SaveTable( table );
  // then go also over the ContentNodes of the EndBoxes and collect
  // all paragraph attributes
  if( m_bSaveContentAttr )
      pOrig->SaveContentAttrs( &rDoc );

  if (bUndo)
  {
      for (size_t n = m_Undos.size(); 0 < n; --n)
      {
          m_Undos.at(n-1)->UndoImpl(rContext);
      }

      table.SetRowsToRepeat(m_nRepeatHeading);
  }

  m_pSaveTable->RestoreAttr( pTableNd->GetTable(), !bUndo );
  m_pSaveTable.reset( pOrig );
1458}

1460void SwUndoTableAutoFormat::UndoImpl(::sw::UndoRedoContext & rContext)
1461{
  UndoRedo(true, rContext);
1463}

1465void SwUndoTableAutoFormat::RedoImpl(::sw::UndoRedoContext & rContext)
1466{
  UndoRedo(false, rContext);
1468}

1470SwUndoTableNdsChg::SwUndoTableNdsChg( SwUndoId nAction,
                                  const SwSelBoxes& rBoxes,
                                  const SwTableNode& rTableNd,
                                  long nMn, long nMx,
                                  sal_uInt16 nCnt, bool bFlg, bool bSmHght )
  : SwUndo( nAction, &rTableNd.GetDoc() ),
  m_nMin( nMn ), m_nMax( nMx ),
  m_nSttNode( rTableNd.GetIndex() ),
  m_nCount( nCnt ),
  m_bFlag( bFlg ),
  m_bSameHeight( bSmHght )
1481{
  const SwTable& rTable = rTableNd.GetTable();
  m_pSaveTable.reset( new SaveTable( rTable ) );

  // and remember selection
  ReNewBoxes( rBoxes );
1487}

1489void SwUndoTableNdsChg::ReNewBoxes( const SwSelBoxes& rBoxes )
1490{
  if (rBoxes.size() != m_Boxes.size())
  {
      m_Boxes.clear();
      for (size_t n = 0; n < rBoxes.size(); ++n)
      {
          m_Boxes.insert( rBoxes[n]->GetSttIdx() );
      }
  }
1499}

1501SwUndoTableNdsChg::~SwUndoTableNdsChg()
1502{
1503}

1505void SwUndoTableNdsChg::SaveNewBoxes( const SwTableNode& rTableNd,
                                  const SwTableSortBoxes& rOld )
1507{
  const SwTable& rTable = rTableNd.GetTable();
  const SwTableSortBoxes& rTableBoxes = rTable.GetTabSortBoxes();

  OSL_ENSURE( ! IsDelBox(), "wrong Action" )do { if (true && (!(! IsDelBox()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "1511" ": "), "%s", "wrong Action"); } } while (false);
  m_pNewSttNds.reset( new std::set<BoxMove> );

  size_t i = 0;
  for (size_t  n = 0; n < rOld.size(); ++i)
  {
      if( rOld[ n ] == rTableBoxes[ i ] )
          ++n;
      else
          // new box: insert sorted
          m_pNewSttNds->insert( BoxMove(rTableBoxes[ i ]->GetSttIdx()) );
  }

  for( ; i < rTableBoxes.size(); ++i )
      // new box: insert sorted
      m_pNewSttNds->insert( BoxMove(rTableBoxes[ i ]->GetSttIdx()) );
1527}

1529static SwTableLine* lcl_FindTableLine( const SwTable& rTable,
                              const SwTableBox& rBox )
1531{
  SwTableLine* pRet = nullptr;
  // i63949: For nested cells we have to take nLineNo - 1, too, not 0!
  const SwTableLines &rTableLines = ( rBox.GetUpper()->GetUpper() != nullptr ) ?
                                rBox.GetUpper()->GetUpper()->GetTabLines()
                              : rTable.GetTabLines();
  const SwTableLine* pLine = rBox.GetUpper();
  sal_uInt16 nLineNo = rTableLines.GetPos( pLine );
  pRet = rTableLines[nLineNo - 1];

  return pRet;
1542}

1544static const SwTableLines& lcl_FindParentLines( const SwTable& rTable,
                                     const SwTableBox& rBox )
1546{
  const SwTableLines& rRet =
      ( rBox.GetUpper()->GetUpper() != nullptr ) ?
          rBox.GetUpper()->GetUpper()->GetTabLines() :
          rTable.GetTabLines();

  return rRet;
1553}

1555void SwUndoTableNdsChg::SaveNewBoxes( const SwTableNode& rTableNd,
                                  const SwTableSortBoxes& rOld,
                                  const SwSelBoxes& rBoxes,
                                  const std::vector<sal_uLong> &rNodeCnts )
1559{
  const SwTable& rTable = rTableNd.GetTable();
  const SwTableSortBoxes& rTableBoxes = rTable.GetTabSortBoxes();

  OSL_ENSURE( ! IsDelBox(), "wrong Action" )do { if (true && (!(! IsDelBox()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "1563" ": "), "%s", "wrong Action"); } } while (false);
  m_pNewSttNds.reset( new std::set<BoxMove> );

  OSL_ENSURE( rTable.IsNewModel() || rOld.size() + m_nCount * rBoxes.size() == rTableBoxes.size(),do { if (true && (!(rTable.IsNewModel() || rOld.size(
) + m_nCount * rBoxes.size() == rTableBoxes.size()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "1567" ": "), "%s", "unexpected boxes"); } } while (false
)
      "unexpected boxes" )do { if (true && (!(rTable.IsNewModel() || rOld.size(
) + m_nCount * rBoxes.size() == rTableBoxes.size()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "1567" ": "), "%s", "unexpected boxes"); } } while (false
);
  OSL_ENSURE( rOld.size() <= rTableBoxes.size(), "more unexpected boxes" )do { if (true && (!(rOld.size() <= rTableBoxes.size
()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "1568" ": "), "%s", "more unexpected boxes"); } } while (
false);
  for (size_t n = 0, i = 0; i < rTableBoxes.size(); ++i)
  {
      if( ( n < rOld.size() ) &&
          ( rOld[ n ] == rTableBoxes[ i ] ) )
      {
          // box already known? Then nothing to be done.
          ++n;
      }
      else
      {
          // new box found: insert (obey sort order)
          const SwTableBox* pBox = rTableBoxes[ i ];

          // find the source box. It must be one in rBoxes.
          // We found the right one if it's in the same column as pBox.
          // No, if more than one selected cell in the same column has been split,
          // we have to look for the nearest one (i65201)!
          const SwTableBox* pSourceBox = nullptr;
          const SwTableBox* pCheckBox = nullptr;
          const SwTableLine* pBoxLine = pBox->GetUpper();
          sal_uInt16 nLineDiff = lcl_FindParentLines(rTable,*pBox).GetPos(pBoxLine);
          sal_uInt16 nLineNo = 0;
          for (size_t j = 0; j < rBoxes.size(); ++j)
          {
              pCheckBox = rBoxes[j];
              if( pCheckBox->GetUpper()->GetUpper() == pBox->GetUpper()->GetUpper() )
              {
                  const SwTableLine* pCheckLine = pCheckBox->GetUpper();
                  sal_uInt16 nCheckLine = lcl_FindParentLines( rTable, *pCheckBox ).
                  GetPos( pCheckLine );
                  if( ( !pSourceBox || nCheckLine > nLineNo ) && nCheckLine < nLineDiff )
                  {
                      nLineNo = nCheckLine;
                      pSourceBox = pCheckBox;
                  }
              }
          }

          // find the line number difference
          // (to help determine bNodesMoved flag below)
          nLineDiff = nLineDiff - nLineNo;
          OSL_ENSURE( pSourceBox, "Split source box not found!" )do { if (true && (!(pSourceBox))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "1610" ": "), "%s", "Split source box not found!"); } } while
 (false);
          // find out how many nodes the source box used to have
          // (to help determine bNodesMoved flag below)
          size_t nNdsPos = 0;
          while( rBoxes[ nNdsPos ] != pSourceBox )
              ++nNdsPos;
          sal_uLong nNodes = rNodeCnts[ nNdsPos ];

          // When a new table cell is created, it either gets a new
          // node, or it gets node(s) from elsewhere. The undo must
          // know, of course, and thus we must determine here just
          // where pBox's nodes are from:
          // If 1) the source box has lost nodes, and
          //    2) we're in the node range that got nodes
          // then pBox received nodes from elsewhere.
          // If bNodesMoved is set for pBox the undo must move the
          // boxes back, otherwise it must delete them.
          bool bNodesMoved = pSourceBox &&
              ( nNodes != ( pSourceBox->GetSttNd()->EndOfSectionIndex() -
                            pSourceBox->GetSttIdx() ) )
              && ( nNodes - 1 > nLineDiff );
          m_pNewSttNds->insert( BoxMove(pBox->GetSttIdx(), bNodesMoved) );
      }
  }
1634}

1636void SwUndoTableNdsChg::SaveSection( SwStartNode* pSttNd )
1637{
  OSL_ENSURE( IsDelBox(), "wrong Action" )do { if (true && (!(IsDelBox()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "1638" ": "), "%s", "wrong Action"); } } while (false);
  if (m_pDelSects == nullptr)
      m_pDelSects.reset(new SwUndoSaveSections);

  SwTableNode* pTableNd = pSttNd->FindTableNode();
  std::unique_ptr<SwUndoSaveSection, o3tl::default_delete<SwUndoSaveSection>> pSave(new SwUndoSaveSection);
  pSave->SaveSection( SwNodeIndex( *pSttNd ));

  m_pDelSects->push_back(std::move(pSave));
  m_nSttNode = pTableNd->GetIndex();
1648}

1650void SwUndoTableNdsChg::UndoImpl(::sw::UndoRedoContext & rContext)
1651{
  SwDoc & rDoc = rContext.GetDoc();
  SwNodeIndex aIdx( rDoc.GetNodes(), m_nSttNode );

  SwTableNode *const pTableNd = aIdx.GetNode().GetTableNode();
  OSL_ENSURE( pTableNd, "no TableNode" )do { if (true && (!(pTableNd))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "1656" ": "), "%s", "no TableNode"); } } while (false);

  SwTableFormulaUpdate aMsgHint( &pTableNd->GetTable() );
  aMsgHint.m_eFlags = TBL_BOXPTR;
  rDoc.getIDocumentFieldsAccess().UpdateTableFields( &aMsgHint );

  CHECK_TABLE( pTableNd->GetTable() )

  FndBox_ aTmpBox( nullptr, nullptr );
  // ? TL_CHART2: notification or locking of controller required ?

  SwChartDataProvider *pPCD = rDoc.getIDocumentChartDataProviderAccess().GetChartDataProvider();
  SwSelBoxes aDelBoxes;
  std::vector< std::pair<SwTableBox *, sal_uLong> > aDelNodes;
  if( IsDelBox() )
  {
      // Trick: add missing boxes in any line, they will be connected
      // correctly when calling CreateNew
      SwTableBox* pCpyBox = pTableNd->GetTable().GetTabSortBoxes()[0];
      SwTableBoxes& rLnBoxes = pCpyBox->GetUpper()->GetTabBoxes();

      // restore sections
      for (size_t n = m_pDelSects->size(); n; )
      {
          SwUndoSaveSection *const pSave = (*m_pDelSects)[ --n ].get();
          pSave->RestoreSection( &rDoc, &aIdx, SwTableBoxStartNode );
          if( pSave->GetHistory() )
              pSave->GetHistory()->Rollback( &rDoc );
          SwTableBox* pBox = new SwTableBox( static_cast<SwTableBoxFormat*>(pCpyBox->GetFrameFormat()), aIdx,
                                              pCpyBox->GetUpper() );
          rLnBoxes.push_back( pBox );
      }
      m_pDelSects->clear();
  }
  else if( !m_pNewSttNds->empty() )
  {
      // Then the nodes have be moved and not deleted!
      // But for that we need a temp array.
      std::vector<BoxMove> aTmp( m_pNewSttNds->begin(), m_pNewSttNds->end() );

      // backwards
      for (size_t n = aTmp.size(); n > 0 ; )
      {
          --n;
          // delete box from table structure
          sal_uLong nIdx = aTmp[n].index;
          SwTableBox* pBox = pTableNd->GetTable().GetTableBox( nIdx );
          OSL_ENSURE( pBox, "Where is my TableBox?" )do { if (true && (!(pBox))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "1703" ": "), "%s", "Where is my TableBox?"); } } while (
false);

          // TL_CHART2: notify chart about box to be removed
          if (pPCD)
              pPCD->DeleteBox( &pTableNd->GetTable(), *pBox );

          // insert _before_ deleting the section - otherwise the box
          // has no start node so all boxes sort equal in SwSelBoxes
          aDelBoxes.insert(pBox);

          if( aTmp[n].hasMoved )
          {
              SwNodeRange aRg( *pBox->GetSttNd(), 1,
                          *pBox->GetSttNd()->EndOfSectionNode() );

              SwTableLine* pLine = lcl_FindTableLine( pTableNd->GetTable(), *pBox );
              SwNodeIndex aInsPos( *(pLine->GetTabBoxes()[0]->GetSttNd()), 2 );

              // adjust all StartNode indices
              size_t i = n;
              sal_uLong nSttIdx = aInsPos.GetIndex() - 2,
                     nNdCnt = aRg.aEnd.GetIndex() - aRg.aStart.GetIndex();
              while( i && aTmp[ --i ].index > nSttIdx )
                  aTmp[ i ].index += nNdCnt;

              // first delete box
              delete pBox;
              // than move nodes
              rDoc.GetNodes().MoveNodes( aRg, rDoc.GetNodes(), aInsPos, false );
          }
          else
          {
              aDelNodes.emplace_back(pBox, nIdx);
          }
      }
  }
  else
  {
      // Remove nodes from nodes array (backwards!)
      std::set<BoxMove>::reverse_iterator it;
      for( it = m_pNewSttNds->rbegin(); it != m_pNewSttNds->rend(); ++it )
      {
          sal_uLong nIdx = (*it).index;
          SwTableBox* pBox = pTableNd->GetTable().GetTableBox( nIdx );
          OSL_ENSURE( pBox, "Where's my table box?" )do { if (true && (!(pBox))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "1747" ": "), "%s", "Where's my table box?"); } } while (
false);
          // TL_CHART2: notify chart about box to be removed
          if (pPCD)
              pPCD->DeleteBox( &pTableNd->GetTable(), *pBox );
          aDelBoxes.insert(pBox);
          aDelNodes.emplace_back(pBox, nIdx);
      }
  }

  // fdo#57197: before deleting the SwTableBoxes, delete the SwTabFrames
  aTmpBox.SetTableLines(aDelBoxes, pTableNd->GetTable());
  aTmpBox.DelFrames(pTableNd->GetTable());

  // do this _after_ deleting Frames because disposing SwAccessible requires
  // connection to the nodes, see SwAccessibleChild::IsAccessible()
  for (const std::pair<SwTableBox *, sal_uLong> & rDelNode : aDelNodes)
  {
      // first disconnect box from node, otherwise ~SwTableBox would
      // access pBox->pSttNd, deleted by DeleteSection
      rDelNode.first->RemoveFromTable();
      rDoc.getIDocumentContentOperations().DeleteSection(rDoc.GetNodes()[ rDelNode.second ]);
  }

  // Remove boxes from table structure
  for( size_t n = 0; n < aDelBoxes.size(); ++n )
  {
      SwTableBox* pCurrBox = aDelBoxes[n];
      SwTableBoxes* pTBoxes = &pCurrBox->GetUpper()->GetTabBoxes();
      pTBoxes->erase( std::find( pTBoxes->begin(), pTBoxes->end(), pCurrBox ) );
      delete pCurrBox;
  }

  m_pSaveTable->CreateNew( pTableNd->GetTable(), true, false );

  // TL_CHART2: need to inform chart of probably changed cell names
  rDoc.UpdateCharts( pTableNd->GetTable().GetFrameFormat()->GetName() );

  if( IsDelBox() )
      m_nSttNode = pTableNd->GetIndex();
  ClearFEShellTabCols(rDoc, nullptr);
  CHECK_TABLE( pTableNd->GetTable() )
1788}

1790void SwUndoTableNdsChg::RedoImpl(::sw::UndoRedoContext & rContext)
1791{
  SwDoc & rDoc = rContext.GetDoc();

  SwTableNode* pTableNd = rDoc.GetNodes()[ m_nSttNode ]->GetTableNode();
  OSL_ENSURE( pTableNd, "no TableNode" )do { if (true && (!(pTableNd))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "1795" ": "), "%s", "no TableNode"); } } while (false);
  CHECK_TABLE( pTableNd->GetTable() )

  SwSelBoxes aSelBoxes;
  for (const auto& rBox : m_Boxes)
  {
      SwTableBox* pBox = pTableNd->GetTable().GetTableBox( rBox );
      aSelBoxes.insert( pBox );
  }

  // create SelBoxes and call InsertCell/-Row/SplitTable
  switch( GetId() )
  {
  case SwUndoId::TABLE_INSCOL:
      rDoc.InsertCol( aSelBoxes, m_nCount, m_bFlag );
      break;

  case SwUndoId::TABLE_INSROW:
      rDoc.InsertRow( aSelBoxes, m_nCount, m_bFlag );
      break;

  case SwUndoId::TABLE_SPLIT:
      rDoc.SplitTable( aSelBoxes, m_bFlag, m_nCount, m_bSameHeight );
      break;
  case SwUndoId::TABLE_DELBOX:
  case SwUndoId::ROW_DELETE:
  case SwUndoId::COL_DELETE:
      {
          SwTableFormulaUpdate aMsgHint( &pTableNd->GetTable() );
          aMsgHint.m_eFlags = TBL_BOXPTR;
          rDoc.getIDocumentFieldsAccess().UpdateTableFields( &aMsgHint );
          SwTable &rTable = pTableNd->GetTable();
          if( m_nMax > m_nMin && rTable.IsNewModel() )
              rTable.PrepareDeleteCol( m_nMin, m_nMax );
          rTable.DeleteSel( &rDoc, aSelBoxes, nullptr, this, true, true );
          m_nSttNode = pTableNd->GetIndex();
      }
      break;
  default:
      ;
  }
  ClearFEShellTabCols(rDoc, nullptr);
  CHECK_TABLE( pTableNd->GetTable() )
1838}

1840SwUndoTableMerge::SwUndoTableMerge( const SwPaM& rTableSel )
  : SwUndo( SwUndoId::TABLE_MERGE, &rTableSel.GetDoc() ), SwUndRng( rTableSel )
1842{
  const SwTableNode* pTableNd = rTableSel.GetNode().FindTableNode();
  OSL_ENSURE( pTableNd, "Where is the TableNode?" )do { if (true && (!(pTableNd))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "1844" ": "), "%s", "Where is the TableNode?"); } } while
 (false);
  m_pSaveTable.reset( new SaveTable( pTableNd->GetTable() ) );
  m_nTableNode = pTableNd->GetIndex();
1847}

1849SwUndoTableMerge::~SwUndoTableMerge()
1850{
  m_pSaveTable.reset();
  m_vMoves.clear();
  m_pHistory.reset();
1854}

1856void SwUndoTableMerge::UndoImpl(::sw::UndoRedoContext & rContext)
1857{
  SwDoc & rDoc = rContext.GetDoc();
  SwNodeIndex aIdx( rDoc.GetNodes(), m_nTableNode );

  SwTableNode *const pTableNd = aIdx.GetNode().GetTableNode();
  OSL_ENSURE( pTableNd, "no TableNode" )do { if (true && (!(pTableNd))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "1862" ": "), "%s", "no TableNode"); } } while (false);

  SwTableFormulaUpdate aMsgHint( &pTableNd->GetTable() );
  aMsgHint.m_eFlags = TBL_BOXPTR;
  rDoc.getIDocumentFieldsAccess().UpdateTableFields( &aMsgHint );

  // ? TL_CHART2: notification or locking of controller required ?

  // 1. restore deleted boxes:
  // Trick: add missing boxes in any line, they will be connected
  // correctly when calling CreateNew
  SwTableBox *pBox, *pCpyBox = pTableNd->GetTable().GetTabSortBoxes()[0];
  SwTableBoxes& rLnBoxes = pCpyBox->GetUpper()->GetTabBoxes();

  CHECKTABLE(pTableNd->GetTable())CheckTable( pTableNd->GetTable() );

  SwSelBoxes aSelBoxes;
  SwTextFormatColl* pColl = rDoc.getIDocumentStylePoolAccess().GetTextCollFromPool( RES_POOLCOLL_STANDARD );

  for (const auto& rBox : m_Boxes)
  {
      aIdx = rBox;
      SwStartNode* pSttNd = rDoc.GetNodes().MakeTextSection( aIdx,
                                          SwTableBoxStartNode, pColl );
      pBox = new SwTableBox( static_cast<SwTableBoxFormat*>(pCpyBox->GetFrameFormat()), *pSttNd,
                              pCpyBox->GetUpper() );
      rLnBoxes.push_back( pBox );

      aSelBoxes.insert( pBox );
  }

  CHECKTABLE(pTableNd->GetTable())CheckTable( pTableNd->GetTable() );

  SwChartDataProvider *pPCD = rDoc.getIDocumentChartDataProviderAccess().GetChartDataProvider();
  // 2. deleted the inserted boxes
  // delete nodes (from last to first)
  for( size_t n = m_aNewStartNodes.size(); n; )
  {
      // remove box from table structure
      sal_uLong nIdx = m_aNewStartNodes[ --n ];

      if( !nIdx && n )
      {
          nIdx = m_aNewStartNodes[ --n ];
          pBox = pTableNd->GetTable().GetTableBox( nIdx );
          OSL_ENSURE( pBox, "Where is my TableBox?" )do { if (true && (!(pBox))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "1907" ": "), "%s", "Where is my TableBox?"); } } while (
false);

          if( !m_pSaveTable->IsNewModel() )
              rDoc.GetNodes().MakeTextNode( SwNodeIndex(
                  *pBox->GetSttNd()->EndOfSectionNode() ), pColl );

          // this was the separator -> restore moved ones
          for (size_t i = m_vMoves.size(); i; )
          {
              SwTextNode* pTextNd = nullptr;
              sal_Int32 nDelPos = 0;
              SwUndoMove *const pUndo = m_vMoves[ --i ].get();
              if( !pUndo->IsMoveRange() )
              {
                  pTextNd = rDoc.GetNodes()[ pUndo->GetDestSttNode() ]->GetTextNode();
                  nDelPos = pUndo->GetDestSttContent() - 1;
              }
              pUndo->UndoImpl(rContext);
              if( pUndo->IsMoveRange() )
              {
                  // delete the unnecessary node
                  aIdx = pUndo->GetEndNode();
                  SwContentNode *pCNd = aIdx.GetNode().GetContentNode();
                  if( pCNd )
                  {
                      SwNodeIndex aTmp( aIdx, -1 );
                      SwContentNode *pMove = aTmp.GetNode().GetContentNode();
                      if( pMove )
                          pCNd->MoveTo( *pMove );
                  }
                  rDoc.GetNodes().Delete( aIdx );
              }
              else if( pTextNd )
              {
                  // also delete not needed attributes
                  SwIndex aTmpIdx( pTextNd, nDelPos );
                  if( pTextNd->GetpSwpHints() && pTextNd->GetpSwpHints()->Count() )
                      pTextNd->RstTextAttr( aTmpIdx, pTextNd->GetText().getLength() - nDelPos + 1 );
                  // delete separator
                  pTextNd->EraseText( aTmpIdx, 1 );
              }
          }
          nIdx = pBox->GetSttIdx();
      }
      else
          pBox = pTableNd->GetTable().GetTableBox( nIdx );

      if( !m_pSaveTable->IsNewModel() )
      {
          // TL_CHART2: notify chart about box to be removed
          if (pPCD)
              pPCD->DeleteBox( &pTableNd->GetTable(), *pBox );

          SwTableBoxes* pTBoxes = &pBox->GetUpper()->GetTabBoxes();
          pTBoxes->erase( std::find(pTBoxes->begin(), pTBoxes->end(), pBox ) );

          // delete indices from section
          {
              SwNodeIndex aTmpIdx( *pBox->GetSttNd() );
              SwDoc::CorrAbs( SwNodeIndex( aTmpIdx, 1 ),
                          SwNodeIndex( *aTmpIdx.GetNode().EndOfSectionNode() ),
                          SwPosition( aTmpIdx, SwIndex( nullptr, 0 )), true );
          }

          delete pBox;
          rDoc.getIDocumentContentOperations().DeleteSection( rDoc.GetNodes()[ nIdx ] );
      }
  }
  CHECKTABLE(pTableNd->GetTable())CheckTable( pTableNd->GetTable() );

  m_pSaveTable->CreateNew( pTableNd->GetTable(), true, false );

  // TL_CHART2: need to inform chart of probably changed cell names
  rDoc.UpdateCharts( pTableNd->GetTable().GetFrameFormat()->GetName() );

  if( m_pHistory )
  {
      m_pHistory->TmpRollback( &rDoc, 0 );
      m_pHistory->SetTmpEnd( m_pHistory->Count() );
  }
  SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
  pPam->DeleteMark();
  pPam->GetPoint()->nNode = m_nSttNode;
  pPam->GetPoint()->nContent.Assign( pPam->GetContentNode(), m_nSttContent );
  pPam->SetMark();
  pPam->DeleteMark();

  CHECKTABLE(pTableNd->GetTable())CheckTable( pTableNd->GetTable() );
  ClearFEShellTabCols(rDoc, nullptr);
1996}

1998void SwUndoTableMerge::RedoImpl(::sw::UndoRedoContext & rContext)
1999{
  SwDoc & rDoc = rContext.GetDoc();
  SwPaM & rPam( AddUndoRedoPaM(rContext) );
  rDoc.MergeTable(rPam);
2003}

2005void SwUndoTableMerge::MoveBoxContent( SwDoc& rDoc, SwNodeRange& rRg, SwNodeIndex& rPos )
2006{
  SwNodeIndex aTmp( rRg.aStart, -1 ), aTmp2( rPos, -1 );
  std::unique_ptr<SwUndoMove> pUndo(new SwUndoMove( rDoc, rRg, rPos ));
  ::sw::UndoGuard const undoGuard(rDoc.GetIDocumentUndoRedo());
  rDoc.getIDocumentContentOperations().MoveNodeRange( rRg, rPos, m_pSaveTable->IsNewModel() ?
      SwMoveFlags::NO_DELFRMS :
      SwMoveFlags::DEFAULT );
  ++aTmp;
  ++aTmp2;
  pUndo->SetDestRange( aTmp2, rPos, aTmp );

  m_vMoves.push_back(std::move(pUndo));
2018}

2020void SwUndoTableMerge::SetSelBoxes( const SwSelBoxes& rBoxes )
2021{
  // memorize selection
  for (size_t n = 0; n < rBoxes.size(); ++n)
  {
      m_Boxes.insert(rBoxes[n]->GetSttIdx());
  }

  // as separator for inserts of new boxes after shifting
  m_aNewStartNodes.push_back( sal_uLong(0) );

  // The new table model does not delete overlapped cells (by row span),
  // so the rBoxes array might be empty even some cells have been merged.
  if( !rBoxes.empty() )
      m_nTableNode = rBoxes[ 0 ]->GetSttNd()->FindTableNode()->GetIndex();
2035}

2037void SwUndoTableMerge::SaveCollection( const SwTableBox& rBox )
2038{
  if( !m_pHistory )
      m_pHistory.reset(new SwHistory);

  SwNodeIndex aIdx( *rBox.GetSttNd(), 1 );
  SwContentNode* pCNd = aIdx.GetNode().GetContentNode();
  if( !pCNd )
      pCNd = aIdx.GetNodes().GoNext( &aIdx );

  m_pHistory->Add( pCNd->GetFormatColl(), aIdx.GetIndex(), pCNd->GetNodeType());
  if( pCNd->HasSwAttrSet() )
      m_pHistory->CopyFormatAttr( *pCNd->GetpSwAttrSet(), aIdx.GetIndex() );
2050}

2052SwUndoTableNumFormat::SwUndoTableNumFormat( const SwTableBox& rBox,
                                  const SfxItemSet* pNewSet )
  : SwUndo(SwUndoId::TBLNUMFMT, rBox.GetFrameFormat()->GetDoc())
  , m_nFormatIdx(getSwDefaultTextFormat())
  , m_nNewFormatIdx(0)
  , m_fNum(0.0)
  , m_fNewNum(0.0)
  , m_bNewFormat(false)
  , m_bNewFormula(false)
  , m_bNewValue(false)
2062{
  m_nNode = rBox.GetSttIdx();

  m_nNodePos = rBox.IsValidNumTextNd( nullptr == pNewSet );
  SwDoc* pDoc = rBox.GetFrameFormat()->GetDoc();

  if( ULONG_MAX(9223372036854775807L *2UL+1UL) != m_nNodePos )
  {
      SwTextNode* pTNd = pDoc->GetNodes()[ m_nNodePos ]->GetTextNode();

      m_pHistory.reset(new SwHistory);
      SwRegHistory aRHst( *rBox.GetSttNd(), m_pHistory.get() );
      // always save all text atttibutes because of possibly overlapping
      // areas of on/off
      m_pHistory->CopyAttr( pTNd->GetpSwpHints(), m_nNodePos, 0,
                          pTNd->GetText().getLength(), true );

      if( pTNd->HasSwAttrSet() )
          m_pHistory->CopyFormatAttr( *pTNd->GetpSwAttrSet(), m_nNodePos );

      m_aStr = pTNd->GetText();
      if( pTNd->GetpSwpHints() )
          pTNd->GetpSwpHints()->DeRegister();
  }

  m_pBoxSet.reset( new SfxItemSet( pDoc->GetAttrPool(), aTableBoxSetRange ) );
  m_pBoxSet->Put( rBox.GetFrameFormat()->GetAttrSet() );

  if( pNewSet )
  {
      const SfxPoolItem* pItem;
      if( SfxItemState::SET == pNewSet->GetItemState( RES_BOXATR_FORMAT,
              false, &pItem ))
      {
          m_bNewFormat = true;
          m_nNewFormatIdx = static_cast<const SwTableBoxNumFormat*>(pItem)->GetValue();
      }
      if( SfxItemState::SET == pNewSet->GetItemState( RES_BOXATR_FORMULA,
              false, &pItem ))
      {
          m_bNewFormula = true;
          m_aNewFormula = static_cast<const SwTableBoxFormula*>(pItem)->GetFormula();
      }
      if( SfxItemState::SET == pNewSet->GetItemState( RES_BOXATR_VALUE,
              false, &pItem ))
      {
          m_bNewValue = true;
          m_fNewNum = static_cast<const SwTableBoxValue*>(pItem)->GetValue();
      }
  }

  // is a history needed at all?
  if (m_pHistory && !m_pHistory->Count())
  {
      m_pHistory.reset();
  }
2118}

2120SwUndoTableNumFormat::~SwUndoTableNumFormat()
2121{
  m_pHistory.reset();
  m_pBoxSet.reset();
2124}

2126void SwUndoTableNumFormat::UndoImpl(::sw::UndoRedoContext & rContext)
2127{
  OSL_ENSURE( m_pBoxSet, "Where's the stored item set?" )do { if (true && (!(m_pBoxSet))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "2128" ": "), "%s", "Where's the stored item set?"); } }
 while (false);

  SwDoc & rDoc = rContext.GetDoc();
  SwStartNode* pSttNd = rDoc.GetNodes()[ m_nNode ]->
                          FindSttNodeByType( SwTableBoxStartNode );
  OSL_ENSURE( pSttNd, "without StartNode no TableBox" )do { if (true && (!(pSttNd))) { sal_detail_logFormat(
(SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "2133" ": "), "%s", "without StartNode no TableBox"); } }
 while (false);
  SwTableBox* pBox = pSttNd->FindTableNode()->GetTable().GetTableBox(
                                  pSttNd->GetIndex() );
  OSL_ENSURE( pBox, "found no TableBox" )do { if (true && (!(pBox))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "2136" ": "), "%s", "found no TableBox"); } } while (false
);

  SwTableBoxFormat* pFormat = rDoc.MakeTableBoxFormat();
  pFormat->SetFormatAttr( *m_pBoxSet );
  pBox->ChgFrameFormat( pFormat );

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

  SwTextNode* pTextNd = rDoc.GetNodes()[ m_nNodePos ]->GetTextNode();
  // If more than one node was deleted then all "node" attributes were also
  // saved
  if( pTextNd->HasSwAttrSet() )
      pTextNd->ResetAllAttr();

  if( pTextNd->GetpSwpHints() && !m_aStr.isEmpty() )
      pTextNd->ClearSwpHintsArr( true );

  // ChgTextToNum(..) only acts when the strings are different. We need to do
  // the same here.
  if( pTextNd->GetText() != m_aStr )
  {
      rDoc.getIDocumentRedlineAccess().DeleteRedline( *( pBox->GetSttNd() ), false, RedlineType::Any );

      SwIndex aIdx( pTextNd, 0 );
      if( !m_aStr.isEmpty() )
      {
          pTextNd->EraseText( aIdx );
          pTextNd->InsertText( m_aStr, aIdx,
              SwInsertFlags::NOHINTEXPAND );
      }
  }

  if( m_pHistory )
  {
      sal_uInt16 nTmpEnd = m_pHistory->GetTmpEnd();
      m_pHistory->TmpRollback( &rDoc, 0 );
      m_pHistory->SetTmpEnd( nTmpEnd );
  }

  SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
  pPam->DeleteMark();
  pPam->GetPoint()->nNode = m_nNode + 1;
  pPam->GetPoint()->nContent.Assign( pTextNd, 0 );
2180}

2182namespace {

2184/** switch the RedlineFlags on the given document, using
* SetRedlineFlags_intern. This class set the mode in the constructor,
* and changes it back in the destructor, i.e. it uses the
* initialization-is-resource-acquisition idiom.
*/
2189class RedlineFlagsInternGuard
2190{
  SwDoc& mrDoc;
  RedlineFlags meOldRedlineFlags;

2194public:
  RedlineFlagsInternGuard(
      SwDoc& rDoc,                      // change mode of this document
      RedlineFlags eNewRedlineFlags,    // new redline mode
      RedlineFlags eRedlineFlagsMask   /*change only bits set in this mask*/);

  ~RedlineFlagsInternGuard();
2201};

2203}

2205RedlineFlagsInternGuard::RedlineFlagsInternGuard(
  SwDoc& rDoc,
  RedlineFlags eNewRedlineFlags,
  RedlineFlags eRedlineFlagsMask )
  : mrDoc( rDoc ),
    meOldRedlineFlags( rDoc.getIDocumentRedlineAccess().GetRedlineFlags() )
2211{
  mrDoc.getIDocumentRedlineAccess().SetRedlineFlags_intern( ( meOldRedlineFlags & ~eRedlineFlagsMask ) |
                                   ( eNewRedlineFlags & eRedlineFlagsMask ) );
2214}

2216RedlineFlagsInternGuard::~RedlineFlagsInternGuard()
2217{
  mrDoc.getIDocumentRedlineAccess().SetRedlineFlags_intern( meOldRedlineFlags );
2219}

2221void SwUndoTableNumFormat::RedoImpl(::sw::UndoRedoContext & rContext)
2222{
  // Could the box be changed?
  if( !m_pBoxSet )
      return ;

  SwDoc & rDoc = rContext.GetDoc();
  SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());

  pPam->DeleteMark();
  pPam->GetPoint()->nNode = m_nNode;

  SwNode * pNd = & pPam->GetPoint()->nNode.GetNode();
  SwStartNode* pSttNd = pNd->FindSttNodeByType( SwTableBoxStartNode );
  assert(pSttNd && "without StartNode no TableBox")(static_cast <bool> (pSttNd && "without StartNode no TableBox"
) ? void (0) : __assert_fail ("pSttNd && \"without StartNode no TableBox\""
, "/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
, 2235, __extension__ __PRETTY_FUNCTION__));
  SwTableBox* pBox = pSttNd->FindTableNode()->GetTable().GetTableBox(
                                  pSttNd->GetIndex() );
  OSL_ENSURE( pBox, "found no TableBox" )do { if (true && (!(pBox))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "2238" ": "), "%s", "found no TableBox"); } } while (false
);

  SwFrameFormat* pBoxFormat = pBox->ClaimFrameFormat();
  if( m_bNewFormat || m_bNewFormula || m_bNewValue )
  {
      SfxItemSet aBoxSet( rDoc.GetAttrPool(),
                              svl::Items<RES_BOXATR_FORMAT, RES_BOXATR_VALUE>{} );

      // Resetting attributes is not enough. In addition, take care that the
      // text will be also formatted correctly.
      pBoxFormat->LockModify();

      if( m_bNewFormula )
          aBoxSet.Put( SwTableBoxFormula( m_aNewFormula ));
      else
          pBoxFormat->ResetFormatAttr( RES_BOXATR_FORMULA );
      if( m_bNewFormat )
          aBoxSet.Put( SwTableBoxNumFormat( m_nNewFormatIdx ));
      else
          pBoxFormat->ResetFormatAttr( RES_BOXATR_FORMAT );
      if( m_bNewValue )
          aBoxSet.Put( SwTableBoxValue( m_fNewNum ));
      else
          pBoxFormat->ResetFormatAttr( RES_BOXATR_VALUE );
      pBoxFormat->UnlockModify();

      // dvo: When redlining is (was) enabled, setting the attribute
      // will also change the cell content. To allow this, the
      // RedlineFlags::Ignore flag must be removed during Redo. #108450#
      RedlineFlagsInternGuard aGuard( rDoc, RedlineFlags::NONE, RedlineFlags::Ignore );
      pBoxFormat->SetFormatAttr( aBoxSet );
  }
  else if( getSwDefaultTextFormat() != m_nFormatIdx )
  {
      SfxItemSet aBoxSet( rDoc.GetAttrPool(),
                          svl::Items<RES_BOXATR_FORMAT, RES_BOXATR_VALUE>{} );

      aBoxSet.Put( SwTableBoxNumFormat( m_nFormatIdx ));
      aBoxSet.Put( SwTableBoxValue( m_fNum ));

      // Resetting attributes is not enough. In addition, take care that the
      // text will be also formatted correctly.
      pBoxFormat->LockModify();
      pBoxFormat->ResetFormatAttr( RES_BOXATR_FORMULA );
      pBoxFormat->UnlockModify();

      // dvo: When redlining is (was) enabled, setting the attribute
      // will also change the cell content. To allow this, the
      // RedlineFlags::Ignore flag must be removed during Redo. #108450#
      RedlineFlagsInternGuard aGuard( rDoc, RedlineFlags::NONE, RedlineFlags::Ignore );
      pBoxFormat->SetFormatAttr( aBoxSet );
  }
  else
  {
      // it's no number

      // Resetting attributes is not enough. In addition, take care that the
      // text will be also formatted correctly.
      pBoxFormat->SetFormatAttr( *GetDfltAttr( RES_BOXATR_FORMAT ));

      pBoxFormat->ResetFormatAttr( RES_BOXATR_FORMAT, RES_BOXATR_VALUE );
  }

  if( m_bNewFormula )
  {
      // No matter what was set, an update of the table is always a good idea
      SwTableFormulaUpdate aTableUpdate( &pSttNd->FindTableNode()->GetTable() );
      rDoc.getIDocumentFieldsAccess().UpdateTableFields( &aTableUpdate );
  }

  if( !pNd->IsContentNode() )
      pNd = rDoc.GetNodes().GoNext( &pPam->GetPoint()->nNode );
  pPam->GetPoint()->nContent.Assign( static_cast<SwContentNode*>(pNd), 0 );
2311}

2313void SwUndoTableNumFormat::SetBox( const SwTableBox& rBox )
2314{
  m_nNode = rBox.GetSttIdx();
2316}

2318UndoTableCpyTable_Entry::UndoTableCpyTable_Entry( const SwTableBox& rBox )
  : nBoxIdx( rBox.GetSttIdx() ), nOffset( 0 ),
  bJoin( false )
2321{
2322}

2324SwUndoTableCpyTable::SwUndoTableCpyTable(const SwDoc& rDoc)
  : SwUndo( SwUndoId::TBLCPYTBL, &rDoc )
2326{
2327}

2329SwUndoTableCpyTable::~SwUndoTableCpyTable()
2330{
  m_vArr.clear();
  m_pInsRowUndo.reset();
2333}

2335void SwUndoTableCpyTable::UndoImpl(::sw::UndoRedoContext & rContext)
2336{
  SwDoc & rDoc = rContext.GetDoc();
  DEBUG_REDLINE( &rDoc )

  SwTableNode* pTableNd = nullptr;
  for (size_t n = m_vArr.size(); n; )
  {
      UndoTableCpyTable_Entry *const pEntry = m_vArr[ --n ].get();
      sal_uLong nSttPos = pEntry->nBoxIdx + pEntry->nOffset;
      SwStartNode* pSNd = rDoc.GetNodes()[ nSttPos ]->StartOfSectionNode();
      if( !pTableNd )
          pTableNd = pSNd->FindTableNode();

      SwTableBox& rBox = *pTableNd->GetTable().GetTableBox( nSttPos );

      SwNodeIndex aInsIdx( *rBox.GetSttNd(), 1 );
      rDoc.GetNodes().MakeTextNode( aInsIdx, rDoc.GetDfltTextFormatColl() );

      // b62341295: Redline for copying tables
      const SwNode *pEndNode = rBox.GetSttNd()->EndOfSectionNode();
      SwPaM aPam( aInsIdx.GetNode(), *pEndNode );
      std::unique_ptr<SwUndoDelete> pUndo;

      if( IDocumentRedlineAccess::IsRedlineOn( GetRedlineFlags() ) )
      {
          bool bDeleteCompleteParagraph = false;
          bool bShiftPam = false;
          // There are a couple of different situations to consider during redlining
          if( pEntry->pUndo )
          {
              SwUndoDelete *const pUndoDelete =
                  dynamic_cast<SwUndoDelete*>(pEntry->pUndo.get());
              SwUndoRedlineDelete *const pUndoRedlineDelete =
                  dynamic_cast<SwUndoRedlineDelete*>(pEntry->pUndo.get());
              assert(pUndoDelete || pUndoRedlineDelete)(static_cast <bool> (pUndoDelete || pUndoRedlineDelete)
 ? void (0) : __assert_fail ("pUndoDelete || pUndoRedlineDelete"
, "/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
, 2370, __extension__ __PRETTY_FUNCTION__));
              if (pUndoRedlineDelete)
              {
                  // The old content was not empty or he has been merged with the new content
                  bDeleteCompleteParagraph = !pEntry->bJoin; // bJoin is set when merged
                  // Set aTmpIdx to the beginning of the old content
                  SwNodeIndex aTmpIdx( *pEndNode,
                          pUndoRedlineDelete->NodeDiff()-1 );
                  SwTextNode *pText = aTmpIdx.GetNode().GetTextNode();
                  if( pText )
                  {
                      aPam.GetPoint()->nNode = *pText;
                      aPam.GetPoint()->nContent.Assign( pText,
                              pUndoRedlineDelete->ContentStart() );
                  }
                  else
                      *aPam.GetPoint() = SwPosition( aTmpIdx );
              }
              else if (pUndoDelete && pUndoDelete->IsDelFullPara())
              {
                  // When the old content was an empty paragraph, but could not be joined
                  // with the new content (e.g. because of a section or table)
                  // We "save" the aPam.Point, we go one step backwards (because later on the
                  // empty paragraph will be inserted by the undo) and set the "ShiftPam-flag
                  // for step forward later on.
                  bDeleteCompleteParagraph = true;
                  bShiftPam = true;
                  SwNodeIndex aTmpIdx( *pEndNode, -1 );
                  SwTextNode *pText = aTmpIdx.GetNode().GetTextNode();
                  if( pText )
                  {
                      aPam.GetPoint()->nNode = *pText;
                      aPam.GetPoint()->nContent.Assign( pText, 0 );
                  }
                  else
                      *aPam.GetPoint() = SwPosition( aTmpIdx );
              }
          }
          rDoc.getIDocumentRedlineAccess().DeleteRedline( aPam, true, RedlineType::Any );

          if( pEntry->pUndo )
          {
              pEntry->pUndo->UndoImpl(rContext);
              pEntry->pUndo.reset();
          }
          if( bShiftPam )
          {
              // The aPam.Point is at the moment at the last position of the new content and has to be
              // moved to the first position of the old content for the SwUndoDelete operation
              SwNodeIndex aTmpIdx( aPam.GetPoint()->nNode, 1 );
              SwTextNode *pText = aTmpIdx.GetNode().GetTextNode();
              if( pText )
              {
                  aPam.GetPoint()->nNode = *pText;
                  aPam.GetPoint()->nContent.Assign( pText, 0 );
              }
              else
                  *aPam.GetPoint() = SwPosition( aTmpIdx );
          }
          pUndo = std::make_unique<SwUndoDelete>( aPam, bDeleteCompleteParagraph, true );
      }
      else
      {
          pUndo = std::make_unique<SwUndoDelete>( aPam, true );
          if( pEntry->pUndo )
          {
              pEntry->pUndo->UndoImpl(rContext);
              pEntry->pUndo.reset();
          }
      }
      pEntry->pUndo = std::move(pUndo);

      aInsIdx = rBox.GetSttIdx() + 1;
      rDoc.GetNodes().Delete( aInsIdx );

      SfxItemSet aTmpSet(
          rDoc.GetAttrPool(),
          svl::Items<
              RES_VERT_ORIENT, RES_VERT_ORIENT,
              RES_BOXATR_FORMAT, RES_BOXATR_VALUE>{});
      aTmpSet.Put( rBox.GetFrameFormat()->GetAttrSet() );
      if( aTmpSet.Count() )
      {
          SwFrameFormat* pBoxFormat = rBox.ClaimFrameFormat();
          pBoxFormat->ResetFormatAttr( RES_BOXATR_FORMAT, RES_BOXATR_VALUE );
          pBoxFormat->ResetFormatAttr( RES_VERT_ORIENT );
      }

      if( pEntry->pBoxNumAttr )
      {
          rBox.ClaimFrameFormat()->SetFormatAttr( *pEntry->pBoxNumAttr );
          pEntry->pBoxNumAttr.reset();
      }

      if( aTmpSet.Count() )
      {
          pEntry->pBoxNumAttr = std::make_unique<SfxItemSet>(
              rDoc.GetAttrPool(),
              svl::Items<
                  RES_VERT_ORIENT, RES_VERT_ORIENT,
                  RES_BOXATR_FORMAT, RES_BOXATR_VALUE>{});
          pEntry->pBoxNumAttr->Put( aTmpSet );
      }

      pEntry->nOffset = rBox.GetSttIdx() - pEntry->nBoxIdx;
  }

  if( m_pInsRowUndo )
  {
      m_pInsRowUndo->UndoImpl(rContext);
  }
  DEBUG_REDLINE( &rDoc )
2482}

2484void SwUndoTableCpyTable::RedoImpl(::sw::UndoRedoContext & rContext)
2485{
  SwDoc & rDoc = rContext.GetDoc();
  DEBUG_REDLINE( &rDoc )

  if( m_pInsRowUndo )
  {
      m_pInsRowUndo->RedoImpl(rContext);
  }

  SwTableNode* pTableNd = nullptr;
  for (size_t n = 0; n < m_vArr.size(); ++n)
  {
      UndoTableCpyTable_Entry *const pEntry = m_vArr[ n ].get();
      sal_uLong nSttPos = pEntry->nBoxIdx + pEntry->nOffset;
      SwStartNode* pSNd = rDoc.GetNodes()[ nSttPos ]->StartOfSectionNode();
      if( !pTableNd )
          pTableNd = pSNd->FindTableNode();

      SwTableBox& rBox = *pTableNd->GetTable().GetTableBox( nSttPos );

      SwNodeIndex aInsIdx( *rBox.GetSttNd(), 1 );

      // b62341295: Redline for copying tables - Start.
      rDoc.GetNodes().MakeTextNode( aInsIdx, rDoc.GetDfltTextFormatColl() );
      SwPaM aPam( aInsIdx.GetNode(), *rBox.GetSttNd()->EndOfSectionNode());
      std::unique_ptr<SwUndo> pUndo = IDocumentRedlineAccess::IsRedlineOn( GetRedlineFlags() ) ? nullptr : std::make_unique<SwUndoDelete>( aPam, true );
      if( pEntry->pUndo )
      {
          pEntry->pUndo->UndoImpl(rContext);
          if( IDocumentRedlineAccess::IsRedlineOn( GetRedlineFlags() ) )
          {
              // PrepareRedline has to be called with the beginning of the old content
              // When new and old content has been joined, the rIter.pAktPam has been set
              // by the Undo operation to this point.
              // Otherwise aInsIdx has been moved during the Undo operation
              if( pEntry->bJoin )
              {
                  SwPaM const& rLastPam =
                      rContext.GetCursorSupplier().GetCurrentShellCursor();
                  pUndo = PrepareRedline( &rDoc, rBox, *rLastPam.GetPoint(),
                                          pEntry->bJoin, true );
              }
              else
              {
                  SwPosition aTmpPos( aInsIdx );
                  pUndo = PrepareRedline( &rDoc, rBox, aTmpPos, pEntry->bJoin, true );
              }
          }
          pEntry->pUndo.reset();
      }
      pEntry->pUndo = std::move(pUndo);
      // b62341295: Redline for copying tables - End.

      aInsIdx = rBox.GetSttIdx() + 1;
      rDoc.GetNodes().Delete( aInsIdx );

      SfxItemSet aTmpSet(
          rDoc.GetAttrPool(),
          svl::Items<
              RES_VERT_ORIENT, RES_VERT_ORIENT,
              RES_BOXATR_FORMAT, RES_BOXATR_VALUE>{});
      aTmpSet.Put( rBox.GetFrameFormat()->GetAttrSet() );
      if( aTmpSet.Count() )
      {
          SwFrameFormat* pBoxFormat = rBox.ClaimFrameFormat();
          pBoxFormat->ResetFormatAttr( RES_BOXATR_FORMAT, RES_BOXATR_VALUE );
          pBoxFormat->ResetFormatAttr( RES_VERT_ORIENT );
      }
      if( pEntry->pBoxNumAttr )
      {
          rBox.ClaimFrameFormat()->SetFormatAttr( *pEntry->pBoxNumAttr );
          pEntry->pBoxNumAttr.reset();
      }

      if( aTmpSet.Count() )
      {
          pEntry->pBoxNumAttr = std::make_unique<SfxItemSet>(
              rDoc.GetAttrPool(),
              svl::Items<
                  RES_VERT_ORIENT, RES_VERT_ORIENT,
                  RES_BOXATR_FORMAT, RES_BOXATR_VALUE>{});
          pEntry->pBoxNumAttr->Put( aTmpSet );
      }

      pEntry->nOffset = rBox.GetSttIdx() - pEntry->nBoxIdx;
  }
  DEBUG_REDLINE( &rDoc )
2572}

2574void SwUndoTableCpyTable::AddBoxBefore( const SwTableBox& rBox, bool bDelContent )
2575{
  if (!m_vArr.empty() && !bDelContent)
      return;

  UndoTableCpyTable_Entry* pEntry = new UndoTableCpyTable_Entry( rBox );
  m_vArr.push_back(std::unique_ptr<UndoTableCpyTable_Entry>(pEntry));

  SwDoc* pDoc = rBox.GetFrameFormat()->GetDoc();
  DEBUG_REDLINE( pDoc )
  if( bDelContent )
  {
      SwNodeIndex aInsIdx( *rBox.GetSttNd(), 1 );
      pDoc->GetNodes().MakeTextNode( aInsIdx, pDoc->GetDfltTextFormatColl() );
      SwPaM aPam( aInsIdx.GetNode(), *rBox.GetSttNd()->EndOfSectionNode() );

      if( !pDoc->getIDocumentRedlineAccess().IsRedlineOn() )
          pEntry->pUndo = std::make_unique<SwUndoDelete>( aPam, true );
  }

  pEntry->pBoxNumAttr = std::make_unique<SfxItemSet>(
      pDoc->GetAttrPool(),
      svl::Items<
          RES_VERT_ORIENT, RES_VERT_ORIENT,
          RES_BOXATR_FORMAT, RES_BOXATR_VALUE>{});
  pEntry->pBoxNumAttr->Put( rBox.GetFrameFormat()->GetAttrSet() );
  if( !pEntry->pBoxNumAttr->Count() )
  {
      pEntry->pBoxNumAttr.reset();
  }
  DEBUG_REDLINE( pDoc )
2605}

2607void SwUndoTableCpyTable::AddBoxAfter( const SwTableBox& rBox, const SwNodeIndex& rIdx, bool bDelContent )
2608{
  UndoTableCpyTable_Entry *const pEntry = m_vArr.back().get();

  // If the content was deleted then remove also the temporarily created node
  if( bDelContent )
  {
      SwDoc* pDoc = rBox.GetFrameFormat()->GetDoc();
      DEBUG_REDLINE( pDoc )

      if( pDoc->getIDocumentRedlineAccess().IsRedlineOn() )
      {
          SwPosition aTmpPos( rIdx );
          pEntry->pUndo = PrepareRedline( pDoc, rBox, aTmpPos, pEntry->bJoin, false );
      }
      SwNodeIndex aDelIdx( *rBox.GetSttNd(), 1 );
      rBox.GetFrameFormat()->GetDoc()->GetNodes().Delete( aDelIdx );
      DEBUG_REDLINE( pDoc )
  }

  pEntry->nOffset = rBox.GetSttIdx() - pEntry->nBoxIdx;
2628}

2630// PrepareRedline is called from AddBoxAfter() and from Redo() in slightly different situations.
2631// bRedo is set by calling from Redo()
2632// rJoin is false by calling from AddBoxAfter() and will be set if the old and new content has
2633// been merged.
2634// rJoin is true if Redo() is calling and the content has already been merged

2636std::unique_ptr<SwUndo> SwUndoTableCpyTable::PrepareRedline( SwDoc* pDoc, const SwTableBox& rBox,
  const SwPosition& rPos, bool& rJoin, bool bRedo )
2638{
  std::unique_ptr<SwUndo> pUndo;
  // b62341295: Redline for copying tables
  // What's to do?
  // Mark the cell content before rIdx as insertion,
  // mark the cell content behind rIdx as deletion
  // merge text nodes at rIdx if possible
  RedlineFlags eOld = pDoc->getIDocumentRedlineAccess().GetRedlineFlags();
  pDoc->getIDocumentRedlineAccess().SetRedlineFlags_intern( ( eOld | RedlineFlags::DontCombineRedlines ) & ~RedlineFlags::Ignore );
  SwPosition aInsertEnd( rPos );
  SwTextNode* pText;
  if( !rJoin )
  {
      // If the content is not merged, the end of the insertion is at the end of the node
      // _before_ the given position rPos
      --aInsertEnd.nNode;
      pText = aInsertEnd.nNode.GetNode().GetTextNode();
      if( pText )
      {
          aInsertEnd.nContent.Assign(pText, pText->GetText().getLength());
          if( !bRedo && rPos.nNode.GetNode().GetTextNode() )
          {   // Try to merge, if not called by Redo()
              rJoin = true;
              pText->JoinNext();
          }
      }
      else
          aInsertEnd.nContent.Assign(nullptr, 0);
  }
  // For joined (merged) contents the start of deletion and end of insertion are identical
  // otherwise adjacent nodes.
  SwPosition aDeleteStart( rJoin ? aInsertEnd : rPos );
  if( !rJoin )
  {
      pText = aDeleteStart.nNode.GetNode().GetTextNode();
      if( pText )
          aDeleteStart.nContent.Assign( pText, 0 );
  }
  SwPosition aCellEnd( SwNodeIndex( *rBox.GetSttNd()->EndOfSectionNode(), -1 ) );
  pText = aCellEnd.nNode.GetNode().GetTextNode();
  if( pText )
      aCellEnd.nContent.Assign(pText, pText->GetText().getLength());
  if( aDeleteStart != aCellEnd )
  {   // If the old (deleted) part is not empty, here we are...
      SwPaM aDeletePam( aDeleteStart, aCellEnd );
      pUndo = std::make_unique<SwUndoRedlineDelete>( aDeletePam, SwUndoId::DELETE );
      pDoc->getIDocumentRedlineAccess().AppendRedline( new SwRangeRedline( RedlineType::Delete, aDeletePam ), true );
  }
  else if( !rJoin ) // If the old part is empty and joined, we are finished
  {   // if it is not joined, we have to delete this empty paragraph
      aCellEnd = SwPosition(
          SwNodeIndex( *rBox.GetSttNd()->EndOfSectionNode() ));
      SwPaM aTmpPam( aDeleteStart, aCellEnd );
      pUndo = std::make_unique<SwUndoDelete>( aTmpPam, true );
  }
  SwPosition aCellStart( SwNodeIndex( *rBox.GetSttNd(), 2 ) );
  pText = aCellStart.nNode.GetNode().GetTextNode();
  if( pText )
      aCellStart.nContent.Assign( pText, 0 );
  if( aCellStart != aInsertEnd ) // An empty insertion will not been marked
  {
      SwPaM aTmpPam( aCellStart, aInsertEnd );
      pDoc->getIDocumentRedlineAccess().AppendRedline( new SwRangeRedline( RedlineType::Insert, aTmpPam ), true );
  }

  pDoc->getIDocumentRedlineAccess().SetRedlineFlags_intern( eOld );
  return pUndo;
2705}

2707bool SwUndoTableCpyTable::InsertRow( SwTable& rTable, const SwSelBoxes& rBoxes,
                              sal_uInt16 nCnt )
2709{
  SwTableNode* pTableNd = const_cast<SwTableNode*>(rTable.GetTabSortBoxes()[0]->
                              GetSttNd()->FindTableNode());

  m_pInsRowUndo.reset( new SwUndoTableNdsChg( SwUndoId::TABLE_INSROW, rBoxes, *pTableNd,
                                     0, 0, nCnt, true, false ) );
  SwTableSortBoxes aTmpLst( rTable.GetTabSortBoxes() );

  bool bRet = rTable.InsertRow( rTable.GetFrameFormat()->GetDoc(), rBoxes, nCnt, /*bBehind*/true );
  if( bRet )
      m_pInsRowUndo->SaveNewBoxes( *pTableNd, aTmpLst );
  else
  {
      m_pInsRowUndo.reset();
  }
  return bRet;
2725}

2727bool SwUndoTableCpyTable::IsEmpty() const
2728{
  return !m_pInsRowUndo && m_vArr.empty();
2730}

2732SwUndoCpyTable::SwUndoCpyTable(const SwDoc& rDoc)
  : SwUndo( SwUndoId::CPYTBL, &rDoc ), m_nTableNode( 0 )
2734{
2735}

2737SwUndoCpyTable::~SwUndoCpyTable()
2738{
2739}

2741void SwUndoCpyTable::UndoImpl(::sw::UndoRedoContext & rContext)
2742{
  SwDoc & rDoc = rContext.GetDoc();
  SwTableNode* pTNd = rDoc.GetNodes()[ m_nTableNode ]->GetTableNode();

  // move hard page breaks into next node
  SwContentNode* pNextNd = rDoc.GetNodes()[ pTNd->EndOfSectionIndex()+1 ]->GetContentNode();
  if( pNextNd )
  {
      SwFrameFormat* pTableFormat = pTNd->GetTable().GetFrameFormat();
      const SfxPoolItem *pItem;

      if( SfxItemState::SET == pTableFormat->GetItemState( RES_PAGEDESC,
          false, &pItem ) )
          pNextNd->SetAttr( *pItem );

      if( SfxItemState::SET == pTableFormat->GetItemState( RES_BREAK,
          false, &pItem ) )
          pNextNd->SetAttr( *pItem );
  }

  SwPaM aPam( *pTNd, *pTNd->EndOfSectionNode(), 0 , 1 );
  m_pDelete.reset( new SwUndoDelete( aPam, true ) );
2764}

2766void SwUndoCpyTable::RedoImpl(::sw::UndoRedoContext & rContext)
2767{
  m_pDelete->UndoImpl(rContext);
  m_pDelete.reset();
2770}

2772SwUndoSplitTable::SwUndoSplitTable( const SwTableNode& rTableNd,
  std::unique_ptr<SwSaveRowSpan> pRowSp, SplitTable_HeadlineOption eMode, bool bNewSize )
  : SwUndo( SwUndoId::SPLIT_TABLE, &rTableNd.GetDoc() ),
  m_nTableNode( rTableNd.GetIndex() ), m_nOffset( 0 ), mpSaveRowSpan( std::move(pRowSp) ),
  m_nMode( eMode ), m_nFormulaEnd( 0 ), m_bCalcNewSize( bNewSize )
2777{
  switch( m_nMode )
  {
  case SplitTable_HeadlineOption::BoxAttrAllCopy:
          m_pHistory.reset(new SwHistory);
          [[fallthrough]];
  case SplitTable_HeadlineOption::BorderCopy:
  case SplitTable_HeadlineOption::BoxAttrCopy:
      m_pSavedTable.reset(new SaveTable( rTableNd.GetTable(), 1, false ));
      break;
  default: break;
  }
2789}

2791SwUndoSplitTable::~SwUndoSplitTable()
2792{
  m_pSavedTable.reset();
  m_pHistory.reset();
  mpSaveRowSpan.reset();
2796}

2798void SwUndoSplitTable::UndoImpl(::sw::UndoRedoContext & rContext)
2799{
  SwDoc *const pDoc = & rContext.GetDoc();
  SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());

  SwNodeIndex& rIdx = pPam->GetPoint()->nNode;
  rIdx = m_nTableNode + m_nOffset;
  pPam->GetPoint()->nContent.Assign(rIdx.GetNode().GetContentNode(), 0);
  assert(rIdx.GetNode().GetContentNode()->Len() == 0)(static_cast <bool> (rIdx.GetNode().GetContentNode()->
Len() == 0) ? void (0) : __assert_fail ("rIdx.GetNode().GetContentNode()->Len() == 0"
, "/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
, 2806, __extension__ __PRETTY_FUNCTION__)); // empty para inserted

  {
      // avoid asserts from ~SwIndexReg
      SwNodeIndex const idx(pDoc->GetNodes(), m_nTableNode + m_nOffset);
      {
          SwPaM pam(idx);
          pam.Move(fnMoveBackward, GoInContent);
          ::PaMCorrAbs(*pPam, *pam.GetPoint());
      }

      // remove implicitly created paragraph again
      pDoc->GetNodes().Delete( idx );
  }

  rIdx = m_nTableNode + m_nOffset;
  SwTableNode* pTableNd = rIdx.GetNode().GetTableNode();
  SwTable& rTable = pTableNd->GetTable();

  SwTableFormulaUpdate aMsgHint( &rTable );
  aMsgHint.m_eFlags = TBL_BOXPTR;
  pDoc->getIDocumentFieldsAccess().UpdateTableFields( &aMsgHint );

  switch( m_nMode )
  {
  case SplitTable_HeadlineOption::BoxAttrAllCopy:
      if( m_pHistory )
          m_pHistory->TmpRollback( pDoc, m_nFormulaEnd );
      [[fallthrough]];
  case SplitTable_HeadlineOption::BoxAttrCopy:
  case SplitTable_HeadlineOption::BorderCopy:
      {
          m_pSavedTable->CreateNew( rTable, false );
          m_pSavedTable->RestoreAttr( rTable );
      }
      break;

  case SplitTable_HeadlineOption::ContentCopy:
      // the created first line has to be removed again
      {
          SwSelBoxes aSelBoxes;
          SwTableBox* pBox = rTable.GetTableBox( m_nTableNode + m_nOffset + 1 );
          SwTable::SelLineFromBox( pBox, aSelBoxes );
          FndBox_ aTmpBox( nullptr, nullptr );
          aTmpBox.SetTableLines( aSelBoxes, rTable );
          aTmpBox.DelFrames( rTable );
          rTable.DeleteSel( pDoc, aSelBoxes, nullptr, nullptr, false, false );
      }
      break;
  default: break;
  }

  pDoc->GetNodes().MergeTable( rIdx );

  if( m_pHistory )
  {
      m_pHistory->TmpRollback( pDoc, 0 );
      m_pHistory->SetTmpEnd( m_pHistory->Count() );
  }
  if( mpSaveRowSpan )
  {
      pTableNd = rIdx.GetNode().FindTableNode();
      if( pTableNd )
          pTableNd->GetTable().RestoreRowSpan( *mpSaveRowSpan );
  }
  ClearFEShellTabCols(*pDoc, nullptr);
2872}

2874void SwUndoSplitTable::RedoImpl(::sw::UndoRedoContext & rContext)
2875{
  SwDoc *const pDoc = & rContext.GetDoc();
  SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());

  pPam->DeleteMark();
  pPam->GetPoint()->nNode = m_nTableNode;
  pDoc->SplitTable( *pPam->GetPoint(), m_nMode, m_bCalcNewSize );

  ClearFEShellTabCols(*pDoc, nullptr);
2884}

2886void SwUndoSplitTable::RepeatImpl(::sw::RepeatContext & rContext)
2887{
  SwPaM *const pPam = & rContext.GetRepeatPaM();
  SwDoc *const pDoc = & rContext.GetDoc();

  pDoc->SplitTable( *pPam->GetPoint(), m_nMode, m_bCalcNewSize );
  ClearFEShellTabCols(*pDoc, nullptr);
2893}

2895void SwUndoSplitTable::SaveFormula( SwHistory& rHistory )
2896{
  if( !m_pHistory )
      m_pHistory.reset(new SwHistory);

  m_nFormulaEnd = rHistory.Count();
  m_pHistory->Move( 0, &rHistory );
2902}

2904SwUndoMergeTable::SwUndoMergeTable( const SwTableNode& rTableNd,
                              const SwTableNode& rDelTableNd,
                              bool bWithPrv, sal_uInt16 nMd )
  : SwUndo( SwUndoId::MERGE_TABLE, &rTableNd.GetDoc() ),
  m_nMode( nMd ), m_bWithPrev( bWithPrv )
2909{
  // memorize end node of the last table cell that'll stay in position
  if( m_bWithPrev )
1
Assuming field 'm_bWithPrev' is false→
2
←
Taking false branch→
      m_nTableNode = rDelTableNd.EndOfSectionIndex() - 1;
  else
      m_nTableNode = rTableNd.EndOfSectionIndex() - 1;

  m_aName = rDelTableNd.GetTable().GetFrameFormat()->GetName();
  m_pSaveTable.reset(new SaveTable( rDelTableNd.GetTable() ));
3
←
Calling constructor for 'SaveTable'→

  if (m_bWithPrev)
      m_pSaveHdl.reset( new SaveTable( rTableNd.GetTable(), 1 ) );
2921}

2923SwUndoMergeTable::~SwUndoMergeTable()
2924{
  m_pSaveTable.reset();
  m_pSaveHdl.reset();
  m_pHistory.reset();
2928}

2930void SwUndoMergeTable::UndoImpl(::sw::UndoRedoContext & rContext)
2931{
  SwDoc *const pDoc = & rContext.GetDoc();
  SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());

  pPam->DeleteMark();
  SwNodeIndex& rIdx = pPam->GetPoint()->nNode;
  rIdx = m_nTableNode;

  SwTableNode* pTableNd = rIdx.GetNode().FindTableNode();
  SwTable* pTable = &pTableNd->GetTable();

  SwTableFormulaUpdate aMsgHint( pTable );
  aMsgHint.m_eFlags = TBL_BOXPTR;
  pDoc->getIDocumentFieldsAccess().UpdateTableFields( &aMsgHint );

  // get lines for layout update
  FndBox_ aFndBox( nullptr, nullptr );
  aFndBox.SetTableLines( *pTable );
  aFndBox.DelFrames( *pTable );
  // ? TL_CHART2: notification or locking of controller required ?

  SwTableNode* pNew = pDoc->GetNodes().SplitTable( rIdx );

  // update layout
  aFndBox.MakeFrames( *pTable );
  // ? TL_CHART2: notification or locking of controller required ?

  if( m_bWithPrev )
  {
      // move name
      pNew->GetTable().GetFrameFormat()->SetName( pTable->GetFrameFormat()->GetName() );
      m_pSaveHdl->RestoreAttr( pNew->GetTable() );
  }
  else
      pTable = &pNew->GetTable();

  pTable->GetFrameFormat()->SetName( m_aName );
  m_pSaveTable->RestoreAttr( *pTable );

  if( m_pHistory )
  {
      m_pHistory->TmpRollback( pDoc, 0 );
      m_pHistory->SetTmpEnd( m_pHistory->Count() );
  }

  // create frames for the new table
  SwNodeIndex aTmpIdx( *pNew );
  pNew->MakeOwnFrames(&aTmpIdx);

  // position cursor somewhere in content
  SwContentNode* pCNd = pDoc->GetNodes().GoNext( &rIdx );
  pPam->GetPoint()->nContent.Assign( pCNd, 0 );

  ClearFEShellTabCols(*pDoc, nullptr);

  // TL_CHART2: need to inform chart of probably changed cell names
  SwChartDataProvider *pPCD = pDoc->getIDocumentChartDataProviderAccess().GetChartDataProvider();
  if (pPCD)
  {
      pDoc->UpdateCharts( pTable->GetFrameFormat()->GetName() );
      pDoc->UpdateCharts( pNew->GetTable().GetFrameFormat()->GetName() );
  }
2993}

2995void SwUndoMergeTable::RedoImpl(::sw::UndoRedoContext & rContext)
2996{
  SwDoc *const pDoc = & rContext.GetDoc();
  SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());

  pPam->DeleteMark();
  pPam->GetPoint()->nNode = m_nTableNode;
  if( m_bWithPrev )
      pPam->GetPoint()->nNode = m_nTableNode + 3;
  else
      pPam->GetPoint()->nNode = m_nTableNode;

  pDoc->MergeTable( *pPam->GetPoint(), m_bWithPrev, m_nMode );

  ClearFEShellTabCols(*pDoc, nullptr);
3010}

3012void SwUndoMergeTable::RepeatImpl(::sw::RepeatContext & rContext)
3013{
  SwDoc *const pDoc = & rContext.GetDoc();
  SwPaM *const pPam = & rContext.GetRepeatPaM();

  pDoc->MergeTable( *pPam->GetPoint(), m_bWithPrev, m_nMode );
  ClearFEShellTabCols(*pDoc, nullptr);
3019}

3021void SwUndoMergeTable::SaveFormula( SwHistory& rHistory )
3022{
  if( !m_pHistory )
      m_pHistory.reset( new SwHistory );
  m_pHistory->Move( 0, &rHistory );
3026}

3028void InsertSort( std::vector<sal_uInt16>& rArr, sal_uInt16 nIdx )
3029{
  size_t nO = rArr.size();
  size_t nU = 0;
  if( nO > 0 )
  {
      nO--;
      while( nU <= nO )
      {
          const size_t nM = nU + ( nO - nU ) / 2;
          if ( rArr[nM] == nIdx )
          {
              OSL_FAIL( "Index already exists. This should never happen." )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "3040" ": "), "%s", "Index already exists. This should never happen."
); } } while (false);
              return;
          }
          if( rArr[nM] < nIdx )
              nU = nM + 1;
          else if( nM == 0 )
              break;
          else
              nO = nM - 1;
      }
  }
  rArr.insert( rArr.begin() + nU, nIdx );
3052}

3054#if OSL_DEBUG_LEVEL1 > 0
3055void CheckTable( const SwTable& rTable )
3056{
  const SwNodes& rNds = rTable.GetFrameFormat()->GetDoc()->GetNodes();
  const SwTableSortBoxes& rSrtArr = rTable.GetTabSortBoxes();
  for (size_t n = 0; n < rSrtArr.size(); ++n)
  {
      const SwTableBox* pBox = rSrtArr[ n ];
      const SwNode* pNd = pBox->GetSttNd();
      OSL_ENSURE( rNds[ pBox->GetSttIdx() ] == pNd, "Box with wrong StartNode"  )do { if (true && (!(rNds[ pBox->GetSttIdx() ] == pNd
))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/sw/source/core/undo/untbl.cxx"
 ":" "3063" ": "), "%s", "Box with wrong StartNode"); } } while
 (false);
  }
3065}
3066#endif

3068SwUndoTableStyleMake::SwUndoTableStyleMake(const OUString& rName, const SwDoc& rDoc)
  : SwUndo(SwUndoId::TBLSTYLE_CREATE, &rDoc),
  m_sName(rName)
3071{ }

3073SwUndoTableStyleMake::~SwUndoTableStyleMake()
3074{ }

3076void SwUndoTableStyleMake::UndoImpl(::sw::UndoRedoContext & rContext)
3077{
  m_pAutoFormat = rContext.GetDoc().DelTableStyle(m_sName, true);
3079}

3081void SwUndoTableStyleMake::RedoImpl(::sw::UndoRedoContext & rContext)
3082{
  if (m_pAutoFormat)
  {
      SwTableAutoFormat* pFormat = rContext.GetDoc().MakeTableStyle(m_sName, true);
      if (pFormat)
      {
          *pFormat = *m_pAutoFormat;
          m_pAutoFormat.reset();
      }
  }
3092}

3094SwRewriter SwUndoTableStyleMake::GetRewriter() const
3095{
  SwRewriter aResult;
  aResult.AddRule(UndoArg1, m_sName);
  return aResult;
3099}

3101SwUndoTableStyleDelete::SwUndoTableStyleDelete(std::unique_ptr<SwTableAutoFormat> pAutoFormat, const std::vector<SwTable*>& rAffectedTables, const SwDoc& rDoc)
  : SwUndo(SwUndoId::TBLSTYLE_DELETE, &rDoc),
  m_pAutoFormat(std::move(pAutoFormat)),
  m_rAffectedTables(rAffectedTables)
3105{ }

3107SwUndoTableStyleDelete::~SwUndoTableStyleDelete()
3108{ }

3110void SwUndoTableStyleDelete::UndoImpl(::sw::UndoRedoContext & rContext)
3111{
  SwTableAutoFormat* pNewFormat = rContext.GetDoc().MakeTableStyle(m_pAutoFormat->GetName(), true);
  *pNewFormat = *m_pAutoFormat;
  for (size_t i=0; i < m_rAffectedTables.size(); i++)
      m_rAffectedTables[i]->SetTableStyleName(m_pAutoFormat->GetName());
3116}

3118void SwUndoTableStyleDelete::RedoImpl(::sw::UndoRedoContext & rContext)
3119{
  // Don't need to remember deleted table style nor affected tables, because they must be the same as these already known.
  rContext.GetDoc().DelTableStyle(m_pAutoFormat->GetName());
3122}

3124SwRewriter SwUndoTableStyleDelete::GetRewriter() const
3125{
  SwRewriter aResult;
  aResult.AddRule(UndoArg1, m_pAutoFormat->GetName());
  return aResult;
3129}

3131SwUndoTableStyleUpdate::SwUndoTableStyleUpdate(const SwTableAutoFormat& rNewFormat, const SwTableAutoFormat& rOldFormat, const SwDoc& rDoc)
  : SwUndo(SwUndoId::TBLSTYLE_UPDATE, &rDoc)
  , m_pOldFormat(new SwTableAutoFormat(rOldFormat))
  , m_pNewFormat(new SwTableAutoFormat(rNewFormat))
3135{ }

3137SwUndoTableStyleUpdate::~SwUndoTableStyleUpdate()
3138{ }

3140void SwUndoTableStyleUpdate::UndoImpl(::sw::UndoRedoContext & rContext)
3141{
  rContext.GetDoc().ChgTableStyle(m_pNewFormat->GetName(), *m_pOldFormat);
3143}

3145void SwUndoTableStyleUpdate::RedoImpl(::sw::UndoRedoContext & rContext)
3146{
  rContext.GetDoc().ChgTableStyle(m_pNewFormat->GetName(), *m_pNewFormat);
3148}

3150SwRewriter SwUndoTableStyleUpdate::GetRewriter() const
3151{
  SwRewriter aResult;
  aResult.AddRule(UndoArg1, m_pNewFormat->GetName());
  return aResult;
3155}

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