LCOV - code coverage report
Current view: top level - sw/source/core/undo - unsect.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 75 201 37.3 %
Date: 2014-11-03 Functions: 16 23 69.6 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <UndoSection.hxx>
      21             : 
      22             : #include <sfx2/linkmgr.hxx>
      23             : #include <fmtcntnt.hxx>
      24             : #include <doc.hxx>
      25             : #include <IDocumentLinksAdministration.hxx>
      26             : #include <IDocumentRedlineAccess.hxx>
      27             : #include <IDocumentFieldsAccess.hxx>
      28             : #include <docary.hxx>
      29             : #include <swundo.hxx>
      30             : #include <pam.hxx>
      31             : #include <ndtxt.hxx>
      32             : #include <UndoCore.hxx>
      33             : #include <section.hxx>
      34             : #include <rolbck.hxx>
      35             : #include <redline.hxx>
      36             : #include <doctxm.hxx>
      37             : #include <ftnidx.hxx>
      38             : #include <editsh.hxx>
      39             : /// OD 04.10.2002 #102894#
      40             : /// class Calc needed for calculation of the hidden condition of a section.
      41             : #include <calc.hxx>
      42             : 
      43         140 : static SfxItemSet* lcl_GetAttrSet( const SwSection& rSect )
      44             : {
      45             :     // save attributes of the format (columns, color, ...)
      46             :     // Cntnt and Protect items are not interesting since they are already
      47             :     // stored in Section, thus delete them.
      48         140 :     SfxItemSet* pAttr = 0;
      49         140 :     if( rSect.GetFmt() )
      50             :     {
      51         140 :         sal_uInt16 nCnt = 1;
      52         140 :         if( rSect.IsProtect() )
      53          52 :             ++nCnt;
      54             : 
      55         140 :         if( nCnt < rSect.GetFmt()->GetAttrSet().Count() )
      56             :         {
      57         140 :             pAttr = new SfxItemSet( rSect.GetFmt()->GetAttrSet() );
      58         140 :             pAttr->ClearItem( RES_PROTECT );
      59         140 :             pAttr->ClearItem( RES_CNTNT );
      60         140 :             if( !pAttr->Count() )
      61           0 :                 delete pAttr, pAttr = 0;
      62             :         }
      63             :     }
      64         140 :     return pAttr;
      65             : }
      66             : 
      67          72 : SwUndoInsSection::SwUndoInsSection(
      68             :         SwPaM const& rPam, SwSectionData const& rNewData,
      69             :         SfxItemSet const*const pSet, SwTOXBase const*const pTOXBase)
      70             :     : SwUndo( UNDO_INSSECTION ), SwUndRng( rPam )
      71          72 :     , m_pSectionData(new SwSectionData(rNewData))
      72          12 :     , m_pTOXBase( (pTOXBase) ? new SwTOXBase(*pTOXBase) : 0 )
      73          44 :     , m_pAttrSet( (pSet && pSet->Count()) ? new SfxItemSet( *pSet ) : 0 )
      74             :     , m_nSectionNodePos(0)
      75             :     , m_bSplitAtStart(false)
      76             :     , m_bSplitAtEnd(false)
      77         196 :     , m_bUpdateFtn(false)
      78             : {
      79          72 :     SwDoc& rDoc = *(SwDoc*)rPam.GetDoc();
      80          72 :     if( rDoc.getIDocumentRedlineAccess().IsRedlineOn() )
      81             :     {
      82             :         m_pRedlData.reset(new SwRedlineData( nsRedlineType_t::REDLINE_INSERT,
      83           0 :                                         rDoc.getIDocumentRedlineAccess().GetRedlineAuthor() ));
      84           0 :         SetRedlineMode( rDoc.getIDocumentRedlineAccess().GetRedlineMode() );
      85             :     }
      86          72 :         m_pRedlineSaveData.reset( new SwRedlineSaveDatas );
      87          72 :         if( !FillSaveData( rPam, *m_pRedlineSaveData, false ))
      88          70 :             m_pRedlineSaveData.reset( NULL );
      89             : 
      90          72 :     if( !rPam.HasMark() )
      91             :     {
      92          50 :         const SwCntntNode* pCNd = rPam.GetPoint()->nNode.GetNode().GetCntntNode();
      93          86 :         if( pCNd && pCNd->HasSwAttrSet() && (
      94          18 :             !rPam.GetPoint()->nContent.GetIndex() ||
      95           0 :             rPam.GetPoint()->nContent.GetIndex() == pCNd->Len() ))
      96             :         {
      97          18 :             SfxItemSet aBrkSet( rDoc.GetAttrPool(), aBreakSetRange );
      98          18 :             aBrkSet.Put( *pCNd->GetpSwAttrSet() );
      99          18 :             if( aBrkSet.Count() )
     100             :             {
     101           0 :                 m_pHistory.reset( new SwHistory );
     102           0 :                 m_pHistory->CopyFmtAttr( aBrkSet, pCNd->GetIndex() );
     103          18 :             }
     104             :         }
     105             :     }
     106          72 : }
     107             : 
     108         144 : SwUndoInsSection::~SwUndoInsSection()
     109             : {
     110         144 : }
     111             : 
     112           2 : void SwUndoInsSection::UndoImpl(::sw::UndoRedoContext & rContext)
     113             : {
     114           2 :     SwDoc & rDoc = rContext.GetDoc();
     115             : 
     116           2 :     RemoveIdxFromSection( rDoc, m_nSectionNodePos );
     117             : 
     118             :     SwSectionNode *const pNd =
     119           2 :         rDoc.GetNodes()[ m_nSectionNodePos ]->GetSectionNode();
     120             :     OSL_ENSURE( pNd, "wo ist mein SectionNode?" );
     121             : 
     122           2 :     if( IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ))
     123           0 :         rDoc.getIDocumentRedlineAccess().DeleteRedline( *pNd, true, USHRT_MAX );
     124             : 
     125             :     // no selection?
     126           2 :     SwNodeIndex aIdx( *pNd );
     127           4 :     if( ( !nEndNode && COMPLETE_STRING == nEndCntnt ) ||
     128           2 :         ( nSttNode == nEndNode && nSttCntnt == nEndCntnt ))
     129             :         // delete simply all nodes
     130           0 :         rDoc.GetNodes().Delete( aIdx, pNd->EndOfSectionIndex() -
     131           0 :                                         aIdx.GetIndex() );
     132             :     else
     133             :         // just delete format, rest happens automatically
     134           2 :         rDoc.DelSectionFmt( pNd->GetSection().GetFmt() );
     135             : 
     136             :     // do we need to consolidate?
     137           2 :     if (m_bSplitAtStart)
     138             :     {
     139           0 :         Join( rDoc, nSttNode );
     140             :     }
     141             : 
     142           2 :     if (m_bSplitAtEnd)
     143             :     {
     144           0 :         Join( rDoc, nEndNode );
     145             :     }
     146             : 
     147           2 :     if (m_pHistory.get())
     148             :     {
     149           0 :         m_pHistory->TmpRollback( &rDoc, 0, false );
     150             :     }
     151             : 
     152           2 :     if (m_bUpdateFtn)
     153             :     {
     154           0 :         rDoc.GetFtnIdxs().UpdateFtn( aIdx );
     155             :     }
     156             : 
     157           2 :     AddUndoRedoPaM(rContext);
     158             : 
     159           2 :     if( m_pRedlineSaveData.get())
     160           2 :         SetSaveData( rDoc, *m_pRedlineSaveData );
     161           2 : }
     162             : 
     163           0 : void SwUndoInsSection::RedoImpl(::sw::UndoRedoContext & rContext)
     164             : {
     165           0 :     SwDoc & rDoc = rContext.GetDoc();
     166           0 :     SwPaM & rPam( AddUndoRedoPaM(rContext) );
     167             : 
     168           0 :     const SwTOXBaseSection* pUpdateTOX = 0;
     169           0 :     if (m_pTOXBase.get())
     170             :     {
     171           0 :         pUpdateTOX = rDoc.InsertTableOf( *rPam.GetPoint(),
     172           0 :                                         *m_pTOXBase, m_pAttrSet.get(), true);
     173             :     }
     174             :     else
     175             :     {
     176           0 :         rDoc.InsertSwSection(rPam, *m_pSectionData, 0, m_pAttrSet.get(), true);
     177             :     }
     178             : 
     179           0 :     if (m_pHistory.get())
     180             :     {
     181           0 :         m_pHistory->SetTmpEnd( m_pHistory->Count() );
     182             :     }
     183             : 
     184             :     SwSectionNode *const pSectNd =
     185           0 :         rDoc.GetNodes()[ m_nSectionNodePos ]->GetSectionNode();
     186           0 :     if (m_pRedlData.get() &&
     187           0 :         IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode()))
     188             :     {
     189           0 :         RedlineMode_t eOld = rDoc.getIDocumentRedlineAccess().GetRedlineMode();
     190           0 :         rDoc.getIDocumentRedlineAccess().SetRedlineMode_intern((RedlineMode_t)(eOld & ~nsRedlineMode_t::REDLINE_IGNORE));
     191             : 
     192           0 :         SwPaM aPam( *pSectNd->EndOfSectionNode(), *pSectNd, 1 );
     193           0 :         rDoc.getIDocumentRedlineAccess().AppendRedline( new SwRangeRedline( *m_pRedlData, aPam ), true);
     194           0 :         rDoc.getIDocumentRedlineAccess().SetRedlineMode_intern( eOld );
     195             :     }
     196           0 :     else if( !( nsRedlineMode_t::REDLINE_IGNORE & GetRedlineMode() ) &&
     197           0 :             !rDoc.getIDocumentRedlineAccess().GetRedlineTbl().empty() )
     198             :     {
     199           0 :         SwPaM aPam( *pSectNd->EndOfSectionNode(), *pSectNd, 1 );
     200           0 :         rDoc.getIDocumentRedlineAccess().SplitRedline( aPam );
     201             :     }
     202             : 
     203           0 :     if( pUpdateTOX )
     204             :     {
     205             :         // initiate formatting
     206           0 :         SwEditShell* pESh = rDoc.GetEditShell();
     207           0 :         if( pESh )
     208           0 :             pESh->CalcLayout();
     209             : 
     210             :         // insert page numbers
     211           0 :         ((SwTOXBaseSection*)pUpdateTOX)->UpdatePageNum();
     212             :     }
     213           0 : }
     214             : 
     215           0 : void SwUndoInsSection::RepeatImpl(::sw::RepeatContext & rContext)
     216             : {
     217           0 :     SwDoc & rDoc = rContext.GetDoc();
     218           0 :     if (m_pTOXBase.get())
     219             :     {
     220           0 :         rDoc.InsertTableOf(*rContext.GetRepeatPaM().GetPoint(),
     221           0 :                                         *m_pTOXBase, m_pAttrSet.get(), true);
     222             :     }
     223             :     else
     224             :     {
     225           0 :         rDoc.InsertSwSection(rContext.GetRepeatPaM(),
     226           0 :             *m_pSectionData, 0, m_pAttrSet.get());
     227             :     }
     228           0 : }
     229             : 
     230           0 : void SwUndoInsSection::Join( SwDoc& rDoc, sal_uLong nNode )
     231             : {
     232           0 :     SwNodeIndex aIdx( rDoc.GetNodes(), nNode );
     233           0 :     SwTxtNode* pTxtNd = aIdx.GetNode().GetTxtNode();
     234             :     OSL_ENSURE( pTxtNd, "Where is my TextNode?" );
     235             : 
     236             :     {
     237             :         RemoveIdxRel(
     238             :             nNode + 1,
     239           0 :             SwPosition( aIdx, SwIndex( pTxtNd, pTxtNd->GetTxt().getLength() ) ) );
     240             :     }
     241           0 :     pTxtNd->JoinNext();
     242             : 
     243           0 :     if (m_pHistory.get())
     244             :     {
     245           0 :         SwIndex aCntIdx( pTxtNd, 0 );
     246           0 :         pTxtNd->RstTxtAttr( aCntIdx, pTxtNd->Len(), 0, 0, true );
     247           0 :     }
     248           0 : }
     249             : 
     250             : void
     251          10 : SwUndoInsSection::SaveSplitNode(SwTxtNode *const pTxtNd, bool const bAtStart)
     252             : {
     253          10 :     if( pTxtNd->GetpSwpHints() )
     254             :     {
     255           0 :         if (!m_pHistory.get())
     256             :         {
     257           0 :             m_pHistory.reset( new SwHistory );
     258             :         }
     259             :         m_pHistory->CopyAttr( pTxtNd->GetpSwpHints(), pTxtNd->GetIndex(), 0,
     260           0 :                             pTxtNd->GetTxt().getLength(), false );
     261             :     }
     262             : 
     263          10 :     if (bAtStart)
     264             :     {
     265          10 :         m_bSplitAtStart = true;
     266             :     }
     267             :     else
     268             :     {
     269           0 :         m_bSplitAtEnd = true;
     270             :     }
     271          10 : }
     272             : 
     273             : class SwUndoDelSection
     274             :     : public SwUndo
     275             : {
     276             : private:
     277             :     ::std::unique_ptr<SwSectionData> const m_pSectionData; /// section not TOX
     278             :     ::std::unique_ptr<SwTOXBase> const m_pTOXBase; /// set iff section is TOX
     279             :     ::std::unique_ptr<SfxItemSet> const m_pAttrSet;
     280             :     ::boost::shared_ptr< ::sfx2::MetadatableUndo > const m_pMetadataUndo;
     281             :     sal_uLong const m_nStartNode;
     282             :     sal_uLong const m_nEndNode;
     283             : 
     284             : public:
     285             :     SwUndoDelSection(
     286             :         SwSectionFmt const&, SwSection const&, SwNodeIndex const*const);
     287             : 
     288             :     virtual ~SwUndoDelSection();
     289             : 
     290             :     virtual void UndoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE;
     291             :     virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE;
     292             : };
     293             : 
     294           6 : SwUndo * MakeUndoDelSection(SwSectionFmt const& rFormat)
     295             : {
     296             :     return new SwUndoDelSection(rFormat, *rFormat.GetSection(),
     297           6 :                 rFormat.GetCntnt().GetCntntIdx());
     298             : }
     299             : 
     300           6 : SwUndoDelSection::SwUndoDelSection(
     301             :             SwSectionFmt const& rSectionFmt, SwSection const& rSection,
     302             :             SwNodeIndex const*const pIndex)
     303             :     : SwUndo( UNDO_DELSECTION )
     304           6 :     , m_pSectionData( new SwSectionData(rSection) )
     305           6 :     , m_pTOXBase( rSection.ISA( SwTOXBaseSection )
     306           0 :             ? new SwTOXBase(static_cast<SwTOXBaseSection const&>(rSection))
     307             :             : 0 )
     308             :     , m_pAttrSet( ::lcl_GetAttrSet(rSection) )
     309             :     , m_pMetadataUndo( rSectionFmt.CreateUndo() )
     310           6 :     , m_nStartNode( pIndex->GetIndex() )
     311          24 :     , m_nEndNode( pIndex->GetNode().EndOfSectionIndex() )
     312             : {
     313           6 : }
     314             : 
     315          12 : SwUndoDelSection::~SwUndoDelSection()
     316             : {
     317          12 : }
     318             : 
     319           0 : void SwUndoDelSection::UndoImpl(::sw::UndoRedoContext & rContext)
     320             : {
     321           0 :     SwDoc & rDoc = rContext.GetDoc();
     322             : 
     323           0 :     if (m_pTOXBase.get())
     324             :     {
     325           0 :         rDoc.InsertTableOf(m_nStartNode, m_nEndNode-2, *m_pTOXBase,
     326           0 :                 m_pAttrSet.get());
     327             :     }
     328             :     else
     329             :     {
     330           0 :         SwNodeIndex aStt( rDoc.GetNodes(), m_nStartNode );
     331           0 :         SwNodeIndex aEnd( rDoc.GetNodes(), m_nEndNode-2 );
     332           0 :         SwSectionFmt* pFmt = rDoc.MakeSectionFmt( 0 );
     333           0 :         if (m_pAttrSet.get())
     334             :         {
     335           0 :             pFmt->SetFmtAttr( *m_pAttrSet );
     336             :         }
     337             : 
     338             :         /// OD 04.10.2002 #102894#
     339             :         /// remember inserted section node for further calculations
     340           0 :         SwSectionNode* pInsertedSectNd = rDoc.GetNodes().InsertTextSection(
     341           0 :                 aStt, *pFmt, *m_pSectionData, 0, & aEnd);
     342             : 
     343           0 :         if( SfxItemState::SET == pFmt->GetItemState( RES_FTN_AT_TXTEND ) ||
     344           0 :             SfxItemState::SET == pFmt->GetItemState( RES_END_AT_TXTEND ))
     345             :         {
     346           0 :             rDoc.GetFtnIdxs().UpdateFtn( aStt );
     347             :         }
     348             : 
     349             :         /// OD 04.10.2002 #102894#
     350             :         /// consider that section is hidden by condition.
     351             :         /// If section is hidden by condition,
     352             :         /// recalculate condition and update hidden condition flag.
     353             :         /// Recalculation is necessary, because fields, on which the hide
     354             :         /// condition depends, can be changed - fields changes aren't undoable.
     355             :         /// NOTE: setting hidden condition flag also creates/deletes corresponding
     356             :         ///     frames, if the hidden condition flag changes.
     357           0 :         SwSection& aInsertedSect = pInsertedSectNd->GetSection();
     358           0 :         if ( aInsertedSect.IsHidden() &&
     359           0 :              !aInsertedSect.GetCondition().isEmpty() )
     360             :         {
     361           0 :             SwCalc aCalc( rDoc );
     362           0 :             rDoc.getIDocumentFieldsAccess().FldsToCalc(aCalc, pInsertedSectNd->GetIndex(), USHRT_MAX);
     363             :             bool bRecalcCondHidden =
     364           0 :                     aCalc.Calculate( aInsertedSect.GetCondition() ).GetBool();
     365           0 :             aInsertedSect.SetCondHidden( bRecalcCondHidden );
     366             :         }
     367             : 
     368           0 :         pFmt->RestoreMetadata(m_pMetadataUndo);
     369             :     }
     370           0 : }
     371             : 
     372           0 : void SwUndoDelSection::RedoImpl(::sw::UndoRedoContext & rContext)
     373             : {
     374           0 :     SwDoc & rDoc = rContext.GetDoc();
     375             : 
     376             :     SwSectionNode *const pNd =
     377           0 :         rDoc.GetNodes()[ m_nStartNode ]->GetSectionNode();
     378             :     OSL_ENSURE( pNd, "Where is my SectionNode?" );
     379             :     // just delete format, rest happens automatically
     380           0 :     rDoc.DelSectionFmt( pNd->GetSection().GetFmt() );
     381           0 : }
     382             : 
     383             : class SwUndoUpdateSection
     384             :     : public SwUndo
     385             : {
     386             : private:
     387             :     ::std::unique_ptr<SwSectionData> m_pSectionData;
     388             :     ::std::unique_ptr<SfxItemSet> m_pAttrSet;
     389             :     sal_uLong const m_nStartNode;
     390             :     bool const m_bOnlyAttrChanged;
     391             : 
     392             : public:
     393             :     SwUndoUpdateSection(
     394             :         SwSection const&, SwNodeIndex const*const, bool const bOnlyAttr);
     395             : 
     396             :     virtual ~SwUndoUpdateSection();
     397             : 
     398             :     virtual void UndoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE;
     399             :     virtual void RedoImpl( ::sw::UndoRedoContext & ) SAL_OVERRIDE;
     400             : };
     401             : 
     402             : SwUndo *
     403         134 : MakeUndoUpdateSection(SwSectionFmt const& rFormat, bool const bOnlyAttr)
     404             : {
     405             :     return new SwUndoUpdateSection(*rFormat.GetSection(),
     406         134 :                 rFormat.GetCntnt().GetCntntIdx(), bOnlyAttr);
     407             : }
     408             : 
     409         134 : SwUndoUpdateSection::SwUndoUpdateSection(
     410             :         SwSection const& rSection, SwNodeIndex const*const pIndex,
     411             :         bool const bOnlyAttr)
     412             :     : SwUndo( UNDO_CHGSECTION )
     413         134 :     , m_pSectionData( new SwSectionData(rSection) )
     414             :     , m_pAttrSet( ::lcl_GetAttrSet(rSection) )
     415         134 :     , m_nStartNode( pIndex->GetIndex() )
     416         402 :     , m_bOnlyAttrChanged( bOnlyAttr )
     417             : {
     418         134 : }
     419             : 
     420         268 : SwUndoUpdateSection::~SwUndoUpdateSection()
     421             : {
     422         268 : }
     423             : 
     424           0 : void SwUndoUpdateSection::UndoImpl(::sw::UndoRedoContext & rContext)
     425             : {
     426           0 :     SwDoc & rDoc = rContext.GetDoc();
     427             :     SwSectionNode *const pSectNd =
     428           0 :         rDoc.GetNodes()[ m_nStartNode ]->GetSectionNode();
     429             :     OSL_ENSURE( pSectNd, "Where is my SectionNode?" );
     430             : 
     431           0 :     SwSection& rNdSect = pSectNd->GetSection();
     432           0 :     SwFmt* pFmt = rNdSect.GetFmt();
     433             : 
     434           0 :     SfxItemSet* pCur = ::lcl_GetAttrSet( rNdSect );
     435           0 :     if (m_pAttrSet.get())
     436             :     {
     437             :         // The Content and Protect items must persist
     438             :         const SfxPoolItem* pItem;
     439           0 :         m_pAttrSet->Put( pFmt->GetFmtAttr( RES_CNTNT ));
     440           0 :         if( SfxItemState::SET == pFmt->GetItemState( RES_PROTECT, true, &pItem ))
     441             :         {
     442           0 :             m_pAttrSet->Put( *pItem );
     443             :         }
     444           0 :         pFmt->DelDiffs( *m_pAttrSet );
     445           0 :         m_pAttrSet->ClearItem( RES_CNTNT );
     446           0 :         pFmt->SetFmtAttr( *m_pAttrSet );
     447             :     }
     448             :     else
     449             :     {
     450             :         // than the old ones need to be deleted
     451           0 :         pFmt->ResetFmtAttr( RES_FRMATR_BEGIN, RES_BREAK );
     452           0 :         pFmt->ResetFmtAttr( RES_HEADER, RES_OPAQUE );
     453           0 :         pFmt->ResetFmtAttr( RES_SURROUND, RES_FRMATR_END-1 );
     454             :     }
     455           0 :     m_pAttrSet.reset(pCur);
     456             : 
     457           0 :     if (!m_bOnlyAttrChanged)
     458             :     {
     459             :         const bool bUpdate =
     460           0 :                (!rNdSect.IsLinkType() && m_pSectionData->IsLinkType())
     461           0 :             || (    !m_pSectionData->GetLinkFileName().isEmpty()
     462           0 :                 &&  (m_pSectionData->GetLinkFileName() !=
     463           0 :                         rNdSect.GetLinkFileName()));
     464             : 
     465             :         // swap stored section data with live section data
     466           0 :         SwSectionData *const pOld( new SwSectionData(rNdSect) );
     467           0 :         rNdSect.SetSectionData(*m_pSectionData);
     468           0 :         m_pSectionData.reset(pOld);
     469             : 
     470           0 :         if( bUpdate )
     471           0 :             rNdSect.CreateLink( CREATE_UPDATE );
     472           0 :         else if( CONTENT_SECTION == rNdSect.GetType() && rNdSect.IsConnected() )
     473             :         {
     474           0 :             rNdSect.Disconnect();
     475           0 :             rDoc.getIDocumentLinksAdministration().GetLinkManager().Remove( &rNdSect.GetBaseLink() );
     476             :         }
     477             :     }
     478           0 : }
     479             : 
     480           0 : void SwUndoUpdateSection::RedoImpl(::sw::UndoRedoContext & rContext)
     481             : {
     482           0 :     UndoImpl(rContext);
     483         270 : }
     484             : 
     485             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10