sw/source/core/undo/unsect.cxx

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