sw/source/core/undo/unnum.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 <UndoNumbering.hxx>
  21 #include <hintids.hxx>
  22 #include <editeng/lrspitem.hxx>
  23 #include <doc.hxx>
  24 #include <IDocumentUndoRedo.hxx>
  25 #include <swundo.hxx>
  26 #include <pam.hxx>
  27 #include <ndtxt.hxx>
  28 #include <UndoCore.hxx>
  29 #include <rolbck.hxx>
  30
  31 SwUndoInsNum::SwUndoInsNum( const SwNumRule& rOldRule,
  32                             const SwNumRule& rNewRule,
  33                             SwUndoId nUndoId )
  34     : SwUndo( nUndoId ),
  35     aNumRule( rNewRule ), pHistory( 0 ), nSttSet( ULONG_MAX ),
  36     pOldNumRule( new SwNumRule( rOldRule )), nLRSavePos( 0 )
  37 {
  38 }
  39
  40 SwUndoInsNum::SwUndoInsNum( const SwPaM& rPam, const SwNumRule& rRule )
  41     : SwUndo( UNDO_INSNUM ), SwUndRng( rPam ),
  42     aNumRule( rRule ), pHistory( 0 ),
  43     nSttSet( ULONG_MAX ), pOldNumRule( 0 ), nLRSavePos( 0 )
  44 {
  45 }
  46
  47 SwUndoInsNum::SwUndoInsNum( const SwPosition& rPos, const SwNumRule& rRule,
  48                             const String& rReplaceRule )
  49     : SwUndo( UNDO_INSNUM ),
  50     aNumRule( rRule ), pHistory( 0 ),
  51     nSttSet( ULONG_MAX ), pOldNumRule( 0 ),
  52     sReplaceRule( rReplaceRule ), nLRSavePos( 0 )
  53 {
  54     // No selection!
  55     nEndNode = 0, nEndCntnt = USHRT_MAX;
  56     nSttNode = rPos.nNode.GetIndex();
  57     nSttCntnt = rPos.nContent.GetIndex();
  58 }
  59
  60 SwUndoInsNum::~SwUndoInsNum()
  61 {
  62     delete pHistory;
  63     delete pOldNumRule;
  64 }
  65
  66 SwRewriter SwUndoInsNum::GetRewriter() const
  67 {
  68     SwRewriter aResult;
  69     if( UNDO_INSFMTATTR == GetId() )
  70         aResult.AddRule(UndoArg1, aNumRule.GetName());
  71     return aResult;
  72 }
  73
  74 void SwUndoInsNum::UndoImpl(::sw::UndoRedoContext & rContext)
  75 {
  76     SwDoc & rDoc = rContext.GetDoc();
  77
  78     if( pOldNumRule )
  79         rDoc.ChgNumRuleFmts( *pOldNumRule );
  80
  81     if( pHistory )
  82     {
  83         SwTxtNode* pNd;
  84         if( ULONG_MAX != nSttSet &&
  85             0 != ( pNd = rDoc.GetNodes()[ nSttSet ]->GetTxtNode() ))
  86                 pNd->SetListRestart( sal_True );
  87         else
  88             pNd = 0;
  89
  90
  91         if( nLRSavePos )
  92         {
  93             // Update immediately so that potential "old" LRSpaces will be valid again.
  94             // For that search firstly the correct NumRule names!
  95             if( !pNd && nSttNode )
  96                 pNd = rDoc.GetNodes()[ nSttNode ]->GetTxtNode();
  97
  98             pHistory->TmpRollback( &rDoc, nLRSavePos );
  99
 100         }
 101         pHistory->TmpRollback( &rDoc, 0 );
 102         pHistory->SetTmpEnd( pHistory->Count() );
 103     }
 104
 105     if (nSttNode)
 106     {
 107         AddUndoRedoPaM(rContext);
 108     }
 109 }
 110
 111 void SwUndoInsNum::RedoImpl(::sw::UndoRedoContext & rContext)
 112 {
 113     SwDoc & rDoc = rContext.GetDoc();
 114
 115     if( pOldNumRule )
 116         rDoc.ChgNumRuleFmts( aNumRule );
 117     else if( pHistory )
 118     {
 119         SwPaM & rPam( AddUndoRedoPaM(rContext) );
 120         if( sReplaceRule.Len() )
 121         {
 122             rDoc.ReplaceNumRule(*rPam.GetPoint(),
 123                                 sReplaceRule, aNumRule.GetName() );
 124         }
 125         else
 126         {
 127             // #i42921# - adapt to changed signature
 128             rDoc.SetNumRule(rPam, aNumRule, false);
 129         }
 130     }
 131 }
 132
 133 void SwUndoInsNum::SetLRSpaceEndPos()
 134 {
 135     if( pHistory )
 136         nLRSavePos = pHistory->Count();
 137 }
 138
 139 void SwUndoInsNum::RepeatImpl(::sw::RepeatContext & rContext)
 140 {
 141     SwDoc & rDoc(rContext.GetDoc());
 142     if( nSttNode )
 143     {
 144         if( !sReplaceRule.Len() )
 145         {
 146             // #i42921# - adapt to changed signature
 147             rDoc.SetNumRule(rContext.GetRepeatPaM(), aNumRule, false);
 148         }
 149     }
 150     else
 151     {
 152         rDoc.ChgNumRuleFmts( aNumRule );
 153     }
 154 }
 155
 156 SwHistory* SwUndoInsNum::GetHistory()
 157 {
 158     if( !pHistory )
 159         pHistory = new SwHistory;
 160     return pHistory;
 161 }
 162
 163 void SwUndoInsNum::SaveOldNumRule( const SwNumRule& rOld )
 164 {
 165     if( !pOldNumRule )
 166         pOldNumRule = new SwNumRule( rOld );
 167 }
 168
 169 SwUndoDelNum::SwUndoDelNum( const SwPaM& rPam )
 170     : SwUndo( UNDO_DELNUM ), SwUndRng( rPam )
 171 {
 172     aNodes.reserve( nEndNode - nSttNode > 255 ? 255 : nEndNode - nSttNode );
 173     pHistory = new SwHistory;
 174 }
 175
 176 SwUndoDelNum::~SwUndoDelNum()
 177 {
 178     delete pHistory;
 179 }
 180
 181 void SwUndoDelNum::UndoImpl(::sw::UndoRedoContext & rContext)
 182 {
 183     SwDoc & rDoc = rContext.GetDoc();
 184
 185     pHistory->TmpRollback( &rDoc, 0 );
 186     pHistory->SetTmpEnd( pHistory->Count() );
 187
 188     for( std::vector<NodeLevel>::const_iterator i = aNodes.begin(); i != aNodes.end(); ++i )
 189     {
 190         SwTxtNode* pNd = rDoc.GetNodes()[ i->index ]->GetTxtNode();
 191         OSL_ENSURE( pNd, "Where has the TextNode gone?" );
 192         pNd->SetAttrListLevel( i->level );
 193
 194         if( pNd->GetCondFmtColl() )
 195             pNd->ChkCondColl();
 196     }
 197
 198     AddUndoRedoPaM(rContext);
 199 }
 200
 201 void SwUndoDelNum::RedoImpl(::sw::UndoRedoContext & rContext)
 202 {
 203     SwPaM & rPam( AddUndoRedoPaM(rContext) );
 204     rContext.GetDoc().DelNumRules(rPam);
 205 }
 206
 207 void SwUndoDelNum::RepeatImpl(::sw::RepeatContext & rContext)
 208 {
 209     rContext.GetDoc().DelNumRules(rContext.GetRepeatPaM());
 210 }
 211
 212 void SwUndoDelNum::AddNode( const SwTxtNode& rNd, sal_Bool )
 213 {
 214     if( rNd.GetNumRule() )
 215     {
 216         aNodes.push_back( NodeLevel( rNd.GetIndex(), rNd.GetActualListLevel() ) );
 217     }
 218 }
 219
 220 SwUndoMoveNum::SwUndoMoveNum( const SwPaM& rPam, long nOff, bool bIsOutlMv )
 221     : SwUndo( bIsOutlMv ? UNDO_OUTLINE_UD : UNDO_MOVENUM ),
 222     SwUndRng( rPam ),
 223     nNewStt( 0 ), nOffset( nOff )
 224 {
 225     // nOffset: Down    =>  1
 226     //          Up      => -1
 227 }
 228
 229 void SwUndoMoveNum::UndoImpl(::sw::UndoRedoContext & rContext)
 230 {
 231     sal_uLong nTmpStt = nSttNode, nTmpEnd = nEndNode;
 232
 233     if( nEndNode || USHRT_MAX != nEndCntnt )        // section?
 234     {
 235         if( nNewStt < nSttNode )        // moved forwards
 236             nEndNode = nEndNode - ( nSttNode - nNewStt );
 237         else
 238             nEndNode = nEndNode + ( nNewStt - nSttNode );
 239     }
 240     nSttNode = nNewStt;
 241
 242     SwPaM & rPam( AddUndoRedoPaM(rContext) );
 243     rContext.GetDoc().MoveParagraph( rPam, -nOffset,
 244                                         UNDO_OUTLINE_UD == GetId() );
 245     nSttNode = nTmpStt;
 246     nEndNode = nTmpEnd;
 247 }
 248
 249 void SwUndoMoveNum::RedoImpl(::sw::UndoRedoContext & rContext)
 250 {
 251     SwPaM & rPam( AddUndoRedoPaM(rContext) );
 252     rContext.GetDoc().MoveParagraph(rPam, nOffset, UNDO_OUTLINE_UD == GetId());
 253 }
 254
 255 void SwUndoMoveNum::RepeatImpl(::sw::RepeatContext & rContext)
 256 {
 257     SwDoc & rDoc = rContext.GetDoc();
 258     if( UNDO_OUTLINE_UD == GetId() )
 259     {
 260         rDoc.MoveOutlinePara(rContext.GetRepeatPaM(),
 261                                             0 < nOffset ? 1 : -1 );
 262     }
 263     else
 264     {
 265         rDoc.MoveParagraph(rContext.GetRepeatPaM(), nOffset, false);
 266     }
 267 }
 268
 269 SwUndoNumUpDown::SwUndoNumUpDown( const SwPaM& rPam, short nOff )
 270     : SwUndo( nOff > 0 ? UNDO_NUMUP : UNDO_NUMDOWN ), SwUndRng( rPam ),
 271       nOffset( nOff )
 272 {
 273     // nOffset: Down    =>  1
 274     //          Up      => -1
 275 }
 276
 277 void SwUndoNumUpDown::UndoImpl(::sw::UndoRedoContext & rContext)
 278 {
 279     SwPaM & rPam( AddUndoRedoPaM(rContext) );
 280     rContext.GetDoc().NumUpDown(rPam, 1 != nOffset );
 281 }
 282
 283 void SwUndoNumUpDown::RedoImpl(::sw::UndoRedoContext & rContext)
 284 {
 285     SwPaM & rPam( AddUndoRedoPaM(rContext) );
 286     rContext.GetDoc().NumUpDown(rPam, 1 == nOffset);
 287 }
 288
 289 void SwUndoNumUpDown::RepeatImpl(::sw::RepeatContext & rContext)
 290 {
 291     rContext.GetDoc().NumUpDown(rContext.GetRepeatPaM(), 1 == nOffset);
 292 }
 293
 294 // #115901#
 295 SwUndoNumOrNoNum::SwUndoNumOrNoNum( const SwNodeIndex& rIdx, sal_Bool bOldNum,
 296                                     sal_Bool bNewNum)
 297     : SwUndo( UNDO_NUMORNONUM ), nIdx( rIdx.GetIndex() ), mbNewNum(bNewNum),
 298       mbOldNum(bOldNum)
 299 {
 300 }
 301
 302 // #115901#, #i40034#
 303 void SwUndoNumOrNoNum::UndoImpl(::sw::UndoRedoContext & rContext)
 304 {
 305     SwNodeIndex aIdx( rContext.GetDoc().GetNodes(), nIdx );
 306     SwTxtNode * pTxtNd = aIdx.GetNode().GetTxtNode();
 307
 308     if (NULL != pTxtNd)
 309     {
 310         pTxtNd->SetCountedInList(mbOldNum);
 311     }
 312 }
 313
 314 // #115901#, #i40034#
 315 void SwUndoNumOrNoNum::RedoImpl(::sw::UndoRedoContext & rContext)
 316 {
 317     SwNodeIndex aIdx( rContext.GetDoc().GetNodes(), nIdx );
 318     SwTxtNode * pTxtNd = aIdx.GetNode().GetTxtNode();
 319
 320     if (NULL != pTxtNd)
 321     {
 322         pTxtNd->SetCountedInList(mbNewNum);
 323     }
 324 }
 325
 326 // #115901#
 327 void SwUndoNumOrNoNum::RepeatImpl(::sw::RepeatContext & rContext)
 328 {
 329     SwDoc & rDoc = rContext.GetDoc();
 330     if (mbOldNum && ! mbNewNum)
 331     {
 332         rDoc.NumOrNoNum(rContext.GetRepeatPaM().GetPoint()->nNode, false);
 333     }
 334     else if ( ! mbOldNum && mbNewNum )
 335     {
 336         rDoc.NumOrNoNum(rContext.GetRepeatPaM().GetPoint()->nNode, true);
 337     }
 338 }
 339
 340 SwUndoNumRuleStart::SwUndoNumRuleStart( const SwPosition& rPos, sal_Bool bFlg )
 341     : SwUndo( UNDO_SETNUMRULESTART ),
 342     nIdx( rPos.nNode.GetIndex() ), nOldStt( USHRT_MAX ),
 343     nNewStt( USHRT_MAX ), bSetSttValue( sal_False ), bFlag( bFlg )
 344 {
 345 }
 346
 347 SwUndoNumRuleStart::SwUndoNumRuleStart( const SwPosition& rPos, sal_uInt16 nStt )
 348     : SwUndo( UNDO_SETNUMRULESTART ),
 349     nIdx( rPos.nNode.GetIndex() ),
 350     nOldStt( USHRT_MAX ), nNewStt( nStt ), bSetSttValue( sal_True )
 351 {
 352     SwTxtNode* pTxtNd = rPos.nNode.GetNode().GetTxtNode();
 353     if ( pTxtNd )
 354     {
 355         if ( pTxtNd->HasAttrListRestartValue() )
 356         {
 357             nOldStt = static_cast<sal_uInt16>(pTxtNd->GetAttrListRestartValue());
 358         }
 359         else
 360         {
 361             nOldStt = USHRT_MAX; // indicating, that the list restart value is not set
 362         }
 363     }
 364 }
 365
 366 void SwUndoNumRuleStart::UndoImpl(::sw::UndoRedoContext & rContext)
 367 {
 368     SwDoc & rDoc = rContext.GetDoc();
 369     SwPosition const aPos( *rDoc.GetNodes()[ nIdx ] );
 370     if( bSetSttValue )
 371     {
 372         rDoc.SetNodeNumStart( aPos, nOldStt );
 373     }
 374     else
 375     {
 376         rDoc.SetNumRuleStart( aPos, !bFlag );
 377     }
 378 }
 379
 380 void SwUndoNumRuleStart::RedoImpl(::sw::UndoRedoContext & rContext)
 381 {
 382     SwDoc & rDoc = rContext.GetDoc();
 383     SwPosition const aPos( *rDoc.GetNodes()[ nIdx ] );
 384     if( bSetSttValue )
 385     {
 386         rDoc.SetNodeNumStart( aPos, nNewStt );
 387     }
 388     else
 389     {
 390         rDoc.SetNumRuleStart( aPos, bFlag );
 391     }
 392 }
 393
 394 void SwUndoNumRuleStart::RepeatImpl(::sw::RepeatContext & rContext)
 395 {
 396     SwDoc & rDoc = rContext.GetDoc();
 397     if( bSetSttValue )
 398     {
 399         rDoc.SetNodeNumStart(*rContext.GetRepeatPaM().GetPoint(), nNewStt);
 400     }
 401     else
 402     {
 403         rDoc.SetNumRuleStart(*rContext.GetRepeatPaM().GetPoint(), bFlag);
 404     }
 405 }
 406
 407 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */