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