sw/source/core/undo/unmove.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: unmove.cxx,v $
  10  * $Revision: 1.12 $
  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 <doc.hxx>
  36 #include <pam.hxx>
  37 #include <swundo.hxx>                   // fuer die UndoIds
  38 #include <ndtxt.hxx>
  39 #include <undobj.hxx>
  40 #include <rolbck.hxx>
  41
  42
  43 inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); }
  44
  45 // MOVE
  46
  47 SwUndoMove::SwUndoMove( const SwPaM& rRange, const SwPosition& rMvPos )
  48     : SwUndo( UNDO_MOVE ), SwUndRng( rRange ),
  49     nMvDestNode( rMvPos.nNode.GetIndex() ),
  50     nMvDestCntnt( rMvPos.nContent.GetIndex() ),
  51     bMoveRedlines( false )
  52 {
  53     bMoveRange = bJoinNext = bJoinPrev = FALSE;
  54
  55     // StartNode vorm loeschen von Fussnoten besorgen!
  56     SwDoc* pDoc = rRange.GetDoc();
  57     SwTxtNode* pTxtNd = pDoc->GetNodes()[ nSttNode ]->GetTxtNode();
  58     SwTxtNode* pEndTxtNd = pDoc->GetNodes()[ nEndNode ]->GetTxtNode();
  59
  60     pHistory = new SwHistory;
  61
  62     if( pTxtNd )
  63     {
  64         pHistory->Add( pTxtNd->GetTxtColl(), nSttNode, ND_TEXTNODE );
  65         if ( pTxtNd->GetpSwpHints() )
  66         {
  67             pHistory->CopyAttr( pTxtNd->GetpSwpHints(), nSttNode,
  68                                 0, pTxtNd->GetTxt().Len(), false );
  69         }
  70         if( pTxtNd->HasSwAttrSet() )
  71             pHistory->CopyFmtAttr( *pTxtNd->GetpSwAttrSet(), nSttNode );
  72     }
  73     if( pEndTxtNd && pEndTxtNd != pTxtNd )
  74     {
  75         pHistory->Add( pEndTxtNd->GetTxtColl(), nEndNode, ND_TEXTNODE );
  76         if ( pEndTxtNd->GetpSwpHints() )
  77         {
  78             pHistory->CopyAttr( pEndTxtNd->GetpSwpHints(), nEndNode,
  79                                 0, pEndTxtNd->GetTxt().Len(), false );
  80         }
  81         if( pEndTxtNd->HasSwAttrSet() )
  82             pHistory->CopyFmtAttr( *pEndTxtNd->GetpSwAttrSet(), nEndNode );
  83     }
  84
  85     if( 0 != (pTxtNd = rRange.GetDoc()->GetNodes()[ rMvPos.nNode ]->GetTxtNode() ))
  86     {
  87         pHistory->Add( pTxtNd->GetTxtColl(), nMvDestNode, ND_TEXTNODE );
  88         if ( pTxtNd->GetpSwpHints() )
  89         {
  90             pHistory->CopyAttr( pTxtNd->GetpSwpHints(), nMvDestNode,
  91                                 0, pTxtNd->GetTxt().Len(), false );
  92         }
  93         if( pTxtNd->HasSwAttrSet() )
  94             pHistory->CopyFmtAttr( *pTxtNd->GetpSwAttrSet(), nMvDestNode );
  95     }
  96
  97
  98     nFtnStt = pHistory->Count();
  99     DelFtn( rRange );
 100
 101     if( pHistory && !pHistory->Count() )
 102         DELETEZ( pHistory );
 103 }
 104
 105
 106 SwUndoMove::SwUndoMove( SwDoc* pDoc, const SwNodeRange& rRg,
 107                         const SwNodeIndex& rMvPos )
 108     : SwUndo( UNDO_MOVE ),
 109     nMvDestNode( rMvPos.GetIndex() ),
 110     bMoveRedlines( false )
 111 {
 112     bMoveRange = TRUE;
 113     bJoinNext = bJoinPrev = FALSE;
 114
 115     nSttCntnt = nEndCntnt = nMvDestCntnt = STRING_MAXLEN;
 116
 117     nSttNode = rRg.aStart.GetIndex();
 118     nEndNode = rRg.aEnd.GetIndex();
 119
 120 //      DelFtn( rRange );
 121
 122     // wird aus dem CntntBereich in den Sonderbereich verschoben ?
 123     ULONG nCntntStt = pDoc->GetNodes().GetEndOfAutotext().GetIndex();
 124     if( nMvDestNode < nCntntStt && rRg.aStart.GetIndex() > nCntntStt )
 125     {
 126         // loesche alle Fussnoten. Diese sind dort nicht erwuenscht.
 127         SwPosition aPtPos( rRg.aEnd );
 128         SwCntntNode* pCNd = rRg.aEnd.GetNode().GetCntntNode();
 129         if( pCNd )
 130             aPtPos.nContent.Assign( pCNd, pCNd->Len() );
 131         SwPosition aMkPos( rRg.aStart );
 132         if( 0 != ( pCNd = aMkPos.nNode.GetNode().GetCntntNode() ))
 133             aMkPos.nContent.Assign( pCNd, 0 );
 134
 135         DelCntntIndex( aMkPos, aPtPos, nsDelCntntType::DELCNT_FTN );
 136
 137         if( pHistory && !pHistory->Count() )
 138             DELETEZ( pHistory );
 139     }
 140
 141     nFtnStt = 0;
 142 }
 143
 144
 145
 146 void SwUndoMove::SetDestRange( const SwPaM& rRange,
 147                                 const SwPosition& rInsPos,
 148                                 BOOL bJoin, BOOL bCorrPam )
 149 {
 150     const SwPosition *pStt = rRange.Start(),
 151                     *pEnd = rRange.GetPoint() == pStt
 152                         ? rRange.GetMark()
 153                         : rRange.GetPoint();
 154
 155     nDestSttNode        = pStt->nNode.GetIndex();
 156     nDestSttCntnt       = pStt->nContent.GetIndex();
 157     nDestEndNode        = pEnd->nNode.GetIndex();
 158     nDestEndCntnt       = pEnd->nContent.GetIndex();
 159
 160     nInsPosNode     = rInsPos.nNode.GetIndex();
 161     nInsPosCntnt        = rInsPos.nContent.GetIndex();
 162
 163     if( bCorrPam )
 164     {
 165         nDestSttNode--;
 166         nDestEndNode--;
 167     }
 168
 169     bJoinNext = nDestSttNode != nDestEndNode &&
 170                 pStt->nNode.GetNode().GetTxtNode() &&
 171                 pEnd->nNode.GetNode().GetTxtNode();
 172     bJoinPrev = bJoin;
 173 }
 174
 175
 176 void SwUndoMove::SetDestRange( const SwNodeIndex& rStt,
 177                                 const SwNodeIndex& rEnd,
 178                                 const SwNodeIndex& rInsPos )
 179 {
 180     nDestSttNode = rStt.GetIndex();
 181     nDestEndNode = rEnd.GetIndex();
 182     if( nDestSttNode > nDestEndNode )
 183     {
 184         nDestSttNode = nDestEndNode;
 185         nDestEndNode = rStt.GetIndex();
 186     }
 187     nInsPosNode  = rInsPos.GetIndex();
 188
 189     nDestSttCntnt = nDestEndCntnt = nInsPosCntnt = STRING_MAXLEN;
 190 }
 191
 192
 193 void SwUndoMove::Undo( SwUndoIter& rUndoIter )
 194 {
 195     SwDoc* pDoc = &rUndoIter.GetDoc();
 196     BOOL bUndo = pDoc->DoesUndo();
 197     pDoc->DoUndo( FALSE );
 198
 199     // Block, damit aus diesem gesprungen werden kann
 200     do {
 201         // erzeuge aus den Werten die Insert-Position und den Bereich
 202         SwNodeIndex aIdx( pDoc->GetNodes(), nDestSttNode );
 203
 204         if( bMoveRange )
 205         {
 206             // nur ein Move mit SwRange
 207             SwNodeRange aRg( aIdx, aIdx );
 208             aRg.aEnd = nDestEndNode;
 209             aIdx = nInsPosNode;
 210             bool bSuccess = pDoc->MoveNodeRange( aRg, aIdx,
 211                     IDocumentContentOperations::DOC_MOVEDEFAULT );
 212             if (!bSuccess)
 213                 break;
 214         }
 215         else
 216         {
 217             SwPaM aPam( aIdx.GetNode(), nDestSttCntnt,
 218                         *pDoc->GetNodes()[ nDestEndNode ], nDestEndCntnt );
 219
 220             // #i17764# if redlines are to be moved, we may not remove them before
 221             //          pDoc->Move gets a chance to handle them
 222             if( ! bMoveRedlines )
 223                 RemoveIdxFromRange( aPam, FALSE );
 224
 225             SwPosition aPos( *pDoc->GetNodes()[ nInsPosNode] );
 226             SwCntntNode* pCNd = aPos.nNode.GetNode().GetCntntNode();
 227             aPos.nContent.Assign( pCNd, nInsPosCntnt );
 228
 229             if( pCNd->HasSwAttrSet() )
 230                 pCNd->ResetAllAttr();
 231
 232             if( pCNd->IsTxtNode() && ((SwTxtNode*)pCNd)->GetpSwpHints() )
 233                 ((SwTxtNode*)pCNd)->ClearSwpHintsArr( false );
 234
 235             // an der InsertPos erstmal alle Attribute entfernen,
 236             const bool bSuccess = pDoc->MoveRange( aPam, aPos, (bMoveRedlines)
 237                         ? IDocumentContentOperations::DOC_MOVEREDLINES
 238                         : IDocumentContentOperations::DOC_MOVEDEFAULT );
 239             if (!bSuccess)
 240                 break;
 241
 242             aPam.Exchange();
 243             aPam.DeleteMark();
 244 //                      pDoc->ResetAttr( aPam, FALSE );
 245             if( aPam.GetNode()->IsCntntNode() )
 246                 aPam.GetNode()->GetCntntNode()->ResetAllAttr();
 247             // der Pam wird jetzt aufgegeben.
 248         }
 249
 250         SwTxtNode* pTxtNd = aIdx.GetNode().GetTxtNode();
 251         if( bJoinNext )
 252         {
 253             {
 254                 RemoveIdxRel( aIdx.GetIndex() + 1, SwPosition( aIdx,
 255                         SwIndex( pTxtNd, pTxtNd->GetTxt().Len() ) ) );
 256             }
 257             // sind keine Pams mehr im naechsten TextNode
 258             pTxtNd->JoinNext();
 259         }
 260
 261         if( bJoinPrev && pTxtNd->CanJoinPrev( &aIdx ) )
 262         {
 263             // ?? sind keine Pams mehr im naechsten TextNode ??
 264             pTxtNd = aIdx.GetNode().GetTxtNode();
 265             {
 266                 RemoveIdxRel( aIdx.GetIndex() + 1, SwPosition( aIdx,
 267                         SwIndex( pTxtNd, pTxtNd->GetTxt().Len() ) ) );
 268             }
 269             pTxtNd->JoinNext();
 270         }
 271
 272     } while( FALSE );
 273
 274     if( pHistory )
 275     {
 276         if( nFtnStt != pHistory->Count() )
 277             pHistory->Rollback( pDoc, nFtnStt );
 278         pHistory->TmpRollback( pDoc, 0 );
 279         pHistory->SetTmpEnd( pHistory->Count() );
 280     }
 281
 282     pDoc->DoUndo( bUndo );
 283
 284     // setze noch den Cursor auf den Undo-Bereich
 285     if( !bMoveRange )
 286         SetPaM( rUndoIter );
 287 }
 288
 289
 290 void SwUndoMove::Redo( SwUndoIter& rUndoIter )
 291 {
 292     SwPaM* pPam = rUndoIter.pAktPam;
 293     SwDoc& rDoc = *pPam->GetDoc();
 294
 295     SwNodes& rNds = rDoc.GetNodes();
 296     SwNodeIndex aIdx( rNds, nMvDestNode );
 297
 298     if( bMoveRange )
 299     {
 300         // nur ein Move mit SwRange
 301         SwNodeRange aRg( rNds, nSttNode, rNds, nEndNode );
 302         rDoc.MoveNodeRange( aRg, aIdx, (bMoveRedlines)
 303                 ? IDocumentContentOperations::DOC_MOVEREDLINES
 304                 : IDocumentContentOperations::DOC_MOVEDEFAULT );
 305     }
 306     else
 307     {
 308         SwPaM aPam( *pPam->GetPoint() );
 309         SetPaM( aPam );
 310         SwPosition aMvPos( aIdx, SwIndex( aIdx.GetNode().GetCntntNode(),
 311                                         nMvDestCntnt ));
 312
 313         DelFtn( aPam );
 314         RemoveIdxFromRange( aPam, FALSE );
 315
 316         aIdx = aPam.Start()->nNode;
 317         BOOL bJoinTxt = aIdx.GetNode().IsTxtNode();
 318
 319         aIdx--;
 320         rDoc.MoveRange( aPam, aMvPos,
 321             IDocumentContentOperations::DOC_MOVEDEFAULT );
 322
 323         if( nSttNode != nEndNode && bJoinTxt )
 324         {
 325             aIdx++;
 326             SwTxtNode * pTxtNd = aIdx.GetNode().GetTxtNode();
 327             if( pTxtNd && pTxtNd->CanJoinNext() )
 328             {
 329                 {
 330                     RemoveIdxRel( aIdx.GetIndex() + 1, SwPosition( aIdx,
 331                             SwIndex( pTxtNd, pTxtNd->GetTxt().Len() ) ) );
 332                 }
 333                 pTxtNd->JoinNext();
 334             }
 335         }
 336         *pPam->GetPoint() = *aPam.GetPoint();
 337         pPam->SetMark();
 338         *pPam->GetMark() = *aPam.GetMark();
 339     }
 340 }
 341
 342
 343 void SwUndoMove::DelFtn( const SwPaM& rRange )
 344 {
 345     // wird aus dem CntntBereich in den Sonderbereich verschoben ?
 346     SwDoc* pDoc = rRange.GetDoc();
 347     ULONG nCntntStt = pDoc->GetNodes().GetEndOfAutotext().GetIndex();
 348     if( nMvDestNode < nCntntStt &&
 349         rRange.GetPoint()->nNode.GetIndex() >= nCntntStt )
 350     {
 351         // loesche alle Fussnoten. Diese sind dort nicht erwuenscht.
 352         DelCntntIndex( *rRange.GetMark(), *rRange.GetPoint(),
 353                             nsDelCntntType::DELCNT_FTN );
 354
 355         if( pHistory && !pHistory->Count() )
 356             delete pHistory, pHistory = 0;
 357     }
 358 }
 359
 360 void SwUndoMove::AddTblMrgFlyHstry( SwHistory& rHstr )
 361 {
 362     if( !pHistory )
 363         pHistory = new SwHistory;
 364
 365     USHORT nInsPos = nFtnStt;
 366     nFtnStt = nFtnStt + rHstr.Count();
 367     pHistory->Move( nInsPos, &rHstr );
 368 }
 369