sw/source/core/undo/unsect.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: unsect.cxx,v $
  10  * $Revision: 1.17 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sw.hxx"
  33
  34
  35 #include <svx/linkmgr.hxx>
  36 #include <fmtcntnt.hxx>
  37 #include <doc.hxx>
  38 #include <docary.hxx>
  39 #include <swundo.hxx>                   // fuer die UndoIds
  40 #include <pam.hxx>
  41 #include <ndtxt.hxx>
  42 #include <undobj.hxx>
  43 #include <section.hxx>
  44 #include <rolbck.hxx>
  45 #include <redline.hxx>
  46 #include <doctxm.hxx>
  47 #include <ftnidx.hxx>
  48 #include <editsh.hxx>
  49 /// OD 04.10.2002 #102894#
  50 /// class Calc needed for calculation of the hidden condition of a section.
  51 #include <calc.hxx>
  52
  53
  54 inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); }
  55
  56 SfxItemSet* lcl_GetAttrSet( const SwSection& rSect )
  57 {
  58     // Attribute des Formate sichern (Spalten, Farbe, ... )
  59     // Cntnt- und Protect- Items interessieren nicht (stehen schon in der
  60     // Section), muessen also entfernen werden
  61     SfxItemSet* pAttr = 0;
  62     if( rSect.GetFmt() )
  63     {
  64         USHORT nCnt = 1;
  65         if( rSect.IsProtect() )
  66             ++nCnt;
  67
  68         if( nCnt < rSect.GetFmt()->GetAttrSet().Count() )
  69         {
  70             pAttr = new SfxItemSet( rSect.GetFmt()->GetAttrSet() );
  71             pAttr->ClearItem( RES_PROTECT );
  72             pAttr->ClearItem( RES_CNTNT );
  73             if( !pAttr->Count() )
  74                 delete pAttr, pAttr = 0;
  75         }
  76     }
  77     return pAttr;
  78 }
  79
  80 SwUndoInsSection::SwUndoInsSection( const SwPaM& rPam, const SwSection& rNew,
  81                                     const SfxItemSet* pSet )
  82     : SwUndo( UNDO_INSSECTION ), SwUndRng( rPam ),
  83     pHistory( 0 ), pRedlData( 0 ), pAttr( 0 ), nSectNodePos( 0 )
  84 {
  85     if( rNew.ISA( SwTOXBaseSection ))
  86     {
  87         const SwTOXBase& rBase = (SwTOXBaseSection&)rNew;
  88         pSection = new SwTOXBaseSection( rBase );
  89     }
  90     else
  91         pSection = new SwSection( rNew.GetType(), rNew.GetName() );
  92     *pSection = rNew;
  93
  94     SwDoc& rDoc = *(SwDoc*)rPam.GetDoc();
  95     if( rDoc.IsRedlineOn() )
  96     {
  97         pRedlData = new SwRedlineData( nsRedlineType_t::REDLINE_INSERT,
  98                                         rDoc.GetRedlineAuthor() );
  99         SetRedlineMode( rDoc.GetRedlineMode() );
 100     }
 101
 102     bSplitAtStt = FALSE;
 103     bSplitAtEnd = FALSE;
 104     bUpdateFtn = FALSE;
 105
 106     if( pSet && pSet->Count() )
 107         pAttr = new SfxItemSet( *pSet );
 108
 109     if( !rPam.HasMark() )
 110     {
 111         const SwCntntNode* pCNd = rPam.GetPoint()->nNode.GetNode().GetCntntNode();
 112         if( pCNd && pCNd->HasSwAttrSet() && (
 113             !rPam.GetPoint()->nContent.GetIndex() ||
 114             rPam.GetPoint()->nContent.GetIndex() == pCNd->Len() ))
 115         {
 116             SfxItemSet aBrkSet( rDoc.GetAttrPool(), aBreakSetRange );
 117             aBrkSet.Put( *pCNd->GetpSwAttrSet() );
 118             if( aBrkSet.Count() )
 119             {
 120                 pHistory = new SwHistory;
 121                 pHistory->CopyFmtAttr( aBrkSet, pCNd->GetIndex() );
 122             }
 123         }
 124     }
 125 }
 126
 127
 128 SwUndoInsSection::~SwUndoInsSection()
 129 {
 130     delete pSection;
 131     delete pRedlData;
 132     delete pAttr;
 133
 134     if( pHistory )
 135         delete pHistory;
 136 }
 137
 138
 139
 140 void SwUndoInsSection::Undo( SwUndoIter& rUndoIter )
 141 {
 142     SwDoc& rDoc = rUndoIter.GetDoc();
 143
 144     RemoveIdxFromSection( rDoc, nSectNodePos );
 145
 146     SwSectionNode* pNd = rDoc.GetNodes()[ nSectNodePos ]->GetSectionNode();
 147     ASSERT( pNd, "wo ist mein SectionNode?" );
 148
 149     if( IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ))
 150         rDoc.DeleteRedline( *pNd, true, USHRT_MAX );
 151
 152     // lag keine Selektion vor ??
 153     SwNodeIndex aIdx( *pNd );
 154     if( ( !nEndNode && STRING_MAXLEN == nEndCntnt ) ||
 155         ( nSttNode == nEndNode && nSttCntnt == nEndCntnt ))
 156         // loesche einfach alle Nodes
 157         rDoc.GetNodes().Delete( aIdx, pNd->EndOfSectionIndex() -
 158                                         aIdx.GetIndex() );
 159     else
 160         // einfach das Format loeschen, der Rest erfolgt automatisch
 161         rDoc.DelSectionFmt( pNd->GetSection().GetFmt() );
 162
 163     // muessen wir noch zusammenfassen ?
 164     if( bSplitAtStt )
 165         Join( rDoc, nSttNode );
 166
 167     if( bSplitAtEnd )
 168         Join( rDoc, nEndNode );
 169
 170     if ( pHistory )
 171     {
 172         pHistory->TmpRollback( &rDoc, 0, false );
 173     }
 174
 175     if( bUpdateFtn )
 176         rDoc.GetFtnIdxs().UpdateFtn( aIdx );
 177
 178     SetPaM( rUndoIter );
 179 }
 180
 181
 182 void SwUndoInsSection::Redo( SwUndoIter& rUndoIter )
 183 {
 184     SwDoc& rDoc = rUndoIter.GetDoc();
 185     SetPaM( rUndoIter );
 186
 187     const SwTOXBaseSection* pUpdateTOX = 0;
 188     if( pSection->ISA( SwTOXBaseSection ))
 189     {
 190         const SwTOXBase& rBase = *(SwTOXBaseSection*)pSection;
 191         pUpdateTOX = rDoc.InsertTableOf( *rUndoIter.pAktPam->GetPoint(),
 192                                         rBase, pAttr, TRUE );
 193     }
 194     else
 195     {
 196         rDoc.InsertSwSection( *rUndoIter.pAktPam, *pSection, pAttr, true );
 197     }
 198
 199     if( pHistory )
 200         pHistory->SetTmpEnd( pHistory->Count() );
 201
 202     SwSectionNode* pSectNd = rDoc.GetNodes()[ nSectNodePos ]->GetSectionNode();
 203     if( pRedlData && IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ))
 204     {
 205         RedlineMode_t eOld = rDoc.GetRedlineMode();
 206         rDoc.SetRedlineMode_intern((RedlineMode_t)(eOld & ~nsRedlineMode_t::REDLINE_IGNORE));
 207
 208         SwPaM aPam( *pSectNd->EndOfSectionNode(), *pSectNd, 1 );
 209         rDoc.AppendRedline( new SwRedline( *pRedlData, aPam ), true);
 210         rDoc.SetRedlineMode_intern( eOld );
 211     }
 212     else if( !( nsRedlineMode_t::REDLINE_IGNORE & GetRedlineMode() ) &&
 213             rDoc.GetRedlineTbl().Count() )
 214     {
 215         SwPaM aPam( *pSectNd->EndOfSectionNode(), *pSectNd, 1 );
 216         rDoc.SplitRedline( aPam );
 217     }
 218
 219     if( pUpdateTOX )
 220     {
 221         // Formatierung anstossen
 222         SwEditShell* pESh = rDoc.GetEditShell();
 223         if( pESh )
 224             pESh->CalcLayout();
 225
 226         // Seitennummern eintragen
 227         ((SwTOXBaseSection*)pUpdateTOX)->UpdatePageNum();
 228     }
 229 }
 230
 231
 232 void SwUndoInsSection::Repeat( SwUndoIter& rUndoIter )
 233 {
 234     if( pSection->ISA( SwTOXBaseSection ))
 235     {
 236         const SwTOXBase& rBase = *(SwTOXBaseSection*)pSection;
 237         rUndoIter.GetDoc().InsertTableOf( *rUndoIter.pAktPam->GetPoint(),
 238                                             rBase, pAttr, TRUE );
 239     }
 240     else
 241     {
 242         rUndoIter.GetDoc().InsertSwSection( *rUndoIter.pAktPam,
 243             *pSection, pAttr );
 244     }
 245 }
 246
 247
 248 void SwUndoInsSection::Join( SwDoc& rDoc, ULONG nNode )
 249 {
 250     SwNodeIndex aIdx( rDoc.GetNodes(), nNode );
 251     SwTxtNode* pTxtNd = aIdx.GetNode().GetTxtNode();
 252     ASSERT( pTxtNd, "wo ist mein TextNode?" );
 253
 254     {
 255         RemoveIdxRel( nNode + 1, SwPosition( aIdx,
 256                             SwIndex( pTxtNd, pTxtNd->GetTxt().Len() )));
 257     }
 258     pTxtNd->JoinNext();
 259
 260     if( pHistory )
 261     {
 262         SwIndex aCntIdx( pTxtNd, 0 );
 263         pTxtNd->RstAttr( aCntIdx, pTxtNd->Len(), 0, 0, true );
 264     }
 265 }
 266
 267
 268 void SwUndoInsSection::SaveSplitNode( SwTxtNode* pTxtNd, BOOL bAtStt )
 269 {
 270     if( pTxtNd->GetpSwpHints() )
 271     {
 272         if( !pHistory )
 273             pHistory = new SwHistory;
 274         pHistory->CopyAttr( pTxtNd->GetpSwpHints(), pTxtNd->GetIndex(), 0,
 275                             pTxtNd->GetTxt().Len(), false );
 276     }
 277
 278     if( bAtStt )
 279         bSplitAtStt = TRUE;
 280     else
 281         bSplitAtEnd = TRUE;
 282 }
 283
 284
 285 // -----------------------------
 286
 287 SwUndoDelSection::SwUndoDelSection( const SwSectionFmt& rFmt )
 288      : SwUndo( UNDO_DELSECTION )
 289 {
 290     const SwSection& rSect = *rFmt.GetSection();
 291     if( rSect.ISA( SwTOXBaseSection ))
 292     {
 293         const SwTOXBase& rBase = (SwTOXBaseSection&)rSect;
 294         pSection = new SwTOXBaseSection( rBase );
 295     }
 296     else
 297         pSection = new SwSection( rSect.GetType(), rSect.GetName() );
 298     *pSection = rSect;
 299
 300     pAttr = ::lcl_GetAttrSet( rSect );
 301
 302     const SwNodeIndex* pIdx = rFmt.GetCntnt().GetCntntIdx();
 303     nSttNd = pIdx->GetIndex();
 304     nEndNd = pIdx->GetNode().EndOfSectionIndex();
 305 }
 306
 307
 308 SwUndoDelSection::~SwUndoDelSection()
 309 {
 310     delete pSection;
 311     delete pAttr;
 312 }
 313
 314
 315 void SwUndoDelSection::Undo( SwUndoIter& rUndoIter )
 316 {
 317     SwDoc& rDoc = rUndoIter.GetDoc();
 318
 319     if( pSection->ISA( SwTOXBaseSection ))
 320     {
 321         const SwTOXBase& rBase = *(SwTOXBaseSection*)pSection;
 322         rDoc.InsertTableOf( nSttNd, nEndNd-2, rBase, pAttr );
 323     }
 324     else
 325     {
 326         SwNodeIndex aStt( rDoc.GetNodes(), nSttNd );
 327         SwNodeIndex aEnd( rDoc.GetNodes(), nEndNd-2 );
 328         SwSectionFmt* pFmt = rDoc.MakeSectionFmt( 0 );
 329         if( pAttr )
 330             pFmt->SetFmtAttr( *pAttr );
 331
 332         /// OD 04.10.2002 #102894#
 333         /// remember inserted section node for further calculations
 334         SwSectionNode* pInsertedSectNd =
 335                 rDoc.GetNodes().InsertSection( aStt, *pFmt, *pSection, &aEnd );
 336
 337         if( SFX_ITEM_SET == pFmt->GetItemState( RES_FTN_AT_TXTEND ) ||
 338             SFX_ITEM_SET == pFmt->GetItemState( RES_END_AT_TXTEND ))
 339         {
 340             rDoc.GetFtnIdxs().UpdateFtn( aStt );
 341         }
 342
 343         /// OD 04.10.2002 #102894#
 344         /// consider that section is hidden by condition.
 345         /// If section is hidden by condition,
 346         /// recalculate condition and update hidden condition flag.
 347         /// Recalculation is necessary, because fields, on which the hide
 348         /// condition depends, can be changed - fields changes aren't undoable.
 349         /// NOTE: setting hidden condition flag also creates/deletes corresponding
 350         ///     frames, if the hidden condition flag changes.
 351         SwSection& aInsertedSect = pInsertedSectNd->GetSection();
 352         if ( aInsertedSect.IsHidden() &&
 353              aInsertedSect.GetCondition().Len() > 0 )
 354         {
 355             SwCalc aCalc( rDoc );
 356             rDoc.FldsToCalc(aCalc, pInsertedSectNd->GetIndex(), USHRT_MAX);
 357             bool bRecalcCondHidden =
 358                     aCalc.Calculate( aInsertedSect.GetCondition() ).GetBool() ? true : false;
 359             aInsertedSect.SetCondHidden( bRecalcCondHidden );
 360         }
 361
 362     }
 363 }
 364
 365
 366 void SwUndoDelSection::Redo( SwUndoIter& rUndoIter )
 367 {
 368     SwDoc& rDoc = rUndoIter.GetDoc();
 369
 370     SwSectionNode* pNd = rDoc.GetNodes()[ nSttNd ]->GetSectionNode();
 371     ASSERT( pNd, "wo ist mein SectionNode?" );
 372     // einfach das Format loeschen, der Rest erfolgt automatisch
 373     rDoc.DelSectionFmt( pNd->GetSection().GetFmt() );
 374 }
 375
 376
 377
 378 SwUndoChgSection::SwUndoChgSection( const SwSectionFmt& rFmt, BOOL bOnlyAttr )
 379      : SwUndo( UNDO_CHGSECTION ), bOnlyAttrChgd( bOnlyAttr )
 380 {
 381     const SwSection& rSect = *rFmt.GetSection();
 382     pSection = new SwSection( rSect.GetType(), rSect.GetName() );
 383     *pSection = rSect;
 384
 385     pAttr = ::lcl_GetAttrSet( rSect );
 386
 387     nSttNd = rFmt.GetCntnt().GetCntntIdx()->GetIndex();
 388 }
 389
 390
 391 SwUndoChgSection::~SwUndoChgSection()
 392 {
 393     delete pSection;
 394     delete pAttr;
 395 }
 396
 397
 398 void SwUndoChgSection::Undo( SwUndoIter& rUndoIter )
 399 {
 400     SwDoc& rDoc = rUndoIter.GetDoc();
 401     SwSectionNode* pSectNd = rDoc.GetNodes()[ nSttNd ]->GetSectionNode();
 402     ASSERT( pSectNd, "wo ist mein SectionNode?" );
 403
 404     SwSection& rNdSect = pSectNd->GetSection();
 405     SwFmt* pFmt = rNdSect.GetFmt();
 406
 407     SfxItemSet* pCur = ::lcl_GetAttrSet( rNdSect );
 408     if( pAttr )
 409     {
 410         // das Content- und Protect-Item muss bestehen bleiben
 411         const SfxPoolItem* pItem;
 412         pAttr->Put( pFmt->GetFmtAttr( RES_CNTNT ));
 413         if( SFX_ITEM_SET == pFmt->GetItemState( RES_PROTECT, TRUE, &pItem ))
 414             pAttr->Put( *pItem );
 415         pFmt->DelDiffs( *pAttr );
 416         pAttr->ClearItem( RES_CNTNT );
 417         pFmt->SetFmtAttr( *pAttr );
 418         delete pAttr;
 419     }
 420     else
 421     {
 422         // dann muessen die alten entfernt werden
 423         pFmt->ResetFmtAttr( RES_FRMATR_BEGIN, RES_BREAK );
 424         pFmt->ResetFmtAttr( RES_HEADER, RES_OPAQUE );
 425         pFmt->ResetFmtAttr( RES_SURROUND, RES_FRMATR_END-1 );
 426     }
 427     pAttr = pCur;
 428
 429     if( !bOnlyAttrChgd )
 430     {
 431         BOOL bUpdate = (!rNdSect.IsLinkType() && pSection->IsLinkType() ) ||
 432                             ( pSection->GetLinkFileName().Len() &&
 433                                 pSection->GetLinkFileName() !=
 434                                 rNdSect.GetLinkFileName());
 435
 436         SwSection* pTmp = new SwSection( CONTENT_SECTION, aEmptyStr );
 437         *pTmp = rNdSect;                // das aktuelle sichern
 438
 439         rNdSect = *pSection;    // das alte setzen
 440
 441         delete pSection;
 442         pSection = pTmp;                // das aktuelle ist jetzt das alte
 443
 444         if( bUpdate )
 445             rNdSect.CreateLink( CREATE_UPDATE );
 446         else if( CONTENT_SECTION == rNdSect.GetType() && rNdSect.IsConnected() )
 447         {
 448             rNdSect.Disconnect();
 449             rDoc.GetLinkManager().Remove( &rNdSect.GetBaseLink() );
 450         }
 451     }
 452 }
 453
 454
 455 void SwUndoChgSection::Redo( SwUndoIter& rUndoIter )
 456 {
 457     Undo( rUndoIter );
 458 }