sw/source/core/undo/unins.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 <UndoInsert.hxx>
  21
  22 #include <hintids.hxx>
  23 #include <unotools/charclass.hxx>
  24 #include <editeng/keepitem.hxx>
  25 #include <svx/svdobj.hxx>
  26 #include <osl/diagnose.h>
  27
  28 #include <fmtcntnt.hxx>
  29 #include <frmfmt.hxx>
  30 #include <doc.hxx>
  31 #include <IDocumentUndoRedo.hxx>
  32 #include <IDocumentDrawModelAccess.hxx>
  33 #include <IDocumentRedlineAccess.hxx>
  34 #include <IDocumentLayoutAccess.hxx>
  35 #include <IShellCursorSupplier.hxx>
  36 #include <swundo.hxx>
  37 #include <pam.hxx>
  38 #include <ndtxt.hxx>
  39 #include <UndoCore.hxx>
  40 #include <UndoDelete.hxx>
  41 #include <UndoAttribute.hxx>
  42 #include <rolbck.hxx>
  43 #include <ndgrf.hxx>
  44 #include <ndole.hxx>
  45 #include <grfatr.hxx>
  46 #include <cntfrm.hxx>
  47 #include <flyfrm.hxx>
  48 #include <swcrsr.hxx>
  49 #include <swtable.hxx>
  50 #include <redline.hxx>
  51 #include <docary.hxx>
  52 #include <acorrect.hxx>
  53
  54 #include <strings.hrc>
  55 #include <utility>
  56
  57 using namespace ::com::sun::star;
  58
  59 // INSERT
  60
  61 std::optional<OUString> SwUndoInsert::GetTextFromDoc() const
  62 {
  63     std::optional<OUString> aResult;
  64
  65     SwNodeIndex aNd( m_pDoc->GetNodes(), m_nNode);
  66     SwContentNode* pCNd = aNd.GetNode().GetContentNode();
  67
  68     if( pCNd->IsTextNode() )
  69     {
  70         OUString sText = pCNd->GetTextNode()->GetText();
  71
  72         sal_Int32 nStart = m_nContent-m_nLen;
  73         sal_Int32 nLength = m_nLen;
  74
  75         if (nStart < 0)
  76         {
  77             nLength += nStart;
  78             nStart = 0;
  79         }
  80
  81         aResult = sText.copy(nStart, nLength);
  82     }
  83
  84     return aResult;
  85 }
  86
  87 void SwUndoInsert::Init(const SwNode & rNd)
  88 {
  89     // consider Redline
  90     m_pDoc = const_cast<SwDoc*>(&rNd.GetDoc());
  91     if( m_pDoc->getIDocumentRedlineAccess().IsRedlineOn() )
  92     {
  93         m_pRedlData.reset( new SwRedlineData( RedlineType::Insert,
  94                                        m_pDoc->getIDocumentRedlineAccess().GetRedlineAuthor() ) );
  95         SetRedlineFlags( m_pDoc->getIDocumentRedlineAccess().GetRedlineFlags() );
  96     }
  97
  98     maUndoText = GetTextFromDoc();
  99
 100     m_bCacheComment = false;
 101 }
 102
 103 SwUndoInsert::SwUndoInsert( const SwNode& rNd, sal_Int32 nCnt,
 104             sal_Int32 nL,
 105             const SwInsertFlags nInsertFlags,
 106             bool bWDelim )
 107     : SwUndo(SwUndoId::TYPING, &rNd.GetDoc()),
 108         m_nNode( rNd.GetIndex() ), m_nContent(nCnt), m_nLen(nL),
 109         m_bIsWordDelim( bWDelim ), m_bIsAppend( false )
 110     , m_bWithRsid(false)
 111     , m_nInsertFlags(nInsertFlags)
 112 {
 113     Init(rNd);
 114 }
 115
 116 SwUndoInsert::SwUndoInsert( const SwNode& rNd )
 117     : SwUndo(SwUndoId::SPLITNODE, &rNd.GetDoc()),
 118         m_nNode( rNd.GetIndex() ), m_nContent(0), m_nLen(1),
 119         m_bIsWordDelim( false ), m_bIsAppend( true )
 120     , m_bWithRsid(false)
 121     , m_nInsertFlags(SwInsertFlags::EMPTYEXPAND)
 122 {
 123     Init(rNd);
 124 }
 125
 126 // Check if the next Insert can be combined with the current one. If so
 127 // change the length and InsPos. As a result, SwDoc::Insert will not add a
 128 // new object into the Undo list.
 129
 130 bool SwUndoInsert::CanGrouping( sal_Unicode cIns )
 131 {
 132     if( !m_bIsAppend && m_bIsWordDelim ==
 133         !GetAppCharClass().isLetterNumeric( OUString( cIns )) )
 134     {
 135         m_nLen++;
 136         m_nContent++;
 137
 138         if (maUndoText)
 139             (*maUndoText) += OUStringChar(cIns);
 140
 141         return true;
 142     }
 143     return false;
 144 }
 145
 146 bool SwUndoInsert::CanGrouping( const SwPosition& rPos )
 147 {
 148     bool bRet = false;
 149     if( m_nNode == rPos.GetNodeIndex() &&
 150         m_nContent == rPos.GetContentIndex() )
 151     {
 152         // consider Redline
 153         SwDoc& rDoc = rPos.GetNode().GetDoc();
 154         if( ( ~RedlineFlags::ShowMask & rDoc.getIDocumentRedlineAccess().GetRedlineFlags() ) ==
 155             ( ~RedlineFlags::ShowMask & GetRedlineFlags() ) )
 156         {
 157             bRet = true;
 158
 159             // then there is or was still an active Redline:
 160             // Check if there is another Redline at the InsPosition. If the
 161             // same exists only once, it can be combined.
 162             const SwRedlineTable& rTable = rDoc.getIDocumentRedlineAccess().GetRedlineTable();
 163             if( !rTable.empty() )
 164             {
 165                 SwRedlineData aRData( RedlineType::Insert, rDoc.getIDocumentRedlineAccess().GetRedlineAuthor() );
 166                 const SwContentNode* pIReg = rPos.GetContentNode();
 167                 for(SwRangeRedline* pRedl : rTable)
 168                 {
 169                     const SwPosition& rIdx = *pRedl->End();
 170                     if( pIReg == rIdx.GetContentNode() &&
 171                         m_nContent == rIdx.GetContentIndex() )
 172                     {
 173                         if( !pRedl->HasMark() || !m_pRedlData ||
 174                             *pRedl != *m_pRedlData || *pRedl != aRData )
 175                         {
 176                             bRet = false;
 177                             break;
 178                         }
 179                     }
 180                 }
 181             }
 182         }
 183     }
 184     return bRet;
 185 }
 186
 187 SwUndoInsert::~SwUndoInsert()
 188 {
 189     if (m_oUndoNodeIndex) // delete the section from UndoNodes array
 190     {
 191         // Insert saves the content in IconSection
 192         SwNodes& rUNds = m_oUndoNodeIndex->GetNodes();
 193         rUNds.Delete(*m_oUndoNodeIndex,
 194             rUNds.GetEndOfExtras().GetIndex() - m_oUndoNodeIndex->GetIndex());
 195         m_oUndoNodeIndex.reset();
 196     }
 197     else     // the inserted text
 198     {
 199         maText.reset();
 200     }
 201     m_pRedlData.reset();
 202 }
 203
 204 void SwUndoInsert::UndoImpl(::sw::UndoRedoContext & rContext)
 205 {
 206     SwDoc *const pTmpDoc = & rContext.GetDoc();
 207     SwCursor *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
 208
 209     if( m_bIsAppend )
 210     {
 211         pPam->GetPoint()->Assign(m_nNode);
 212
 213         if( IDocumentRedlineAccess::IsRedlineOn( GetRedlineFlags() ))
 214         {
 215             pPam->SetMark();
 216             pPam->Move( fnMoveBackward );
 217             pPam->Exchange();
 218             pTmpDoc->getIDocumentRedlineAccess().DeleteRedline( *pPam, true, RedlineType::Any );
 219         }
 220         pPam->DeleteMark();
 221         pTmpDoc->getIDocumentContentOperations().DelFullPara( *pPam );
 222         pPam->GetPoint()->SetContent( 0 );
 223     }
 224     else
 225     {
 226         SwNodeOffset nNd = m_nNode;
 227         sal_Int32 nCnt = m_nContent;
 228         if( m_nLen )
 229         {
 230             SwNodeIndex aNd( pTmpDoc->GetNodes(), m_nNode);
 231             SwContentNode* pCNd = aNd.GetNode().GetContentNode();
 232             SwPaM aPaM( *pCNd, m_nContent );
 233
 234             aPaM.SetMark();
 235
 236             SwTextNode * const pTextNode( pCNd->GetTextNode() );
 237             if ( pTextNode )
 238             {
 239                 aPaM.GetPoint()->AdjustContent( - m_nLen );
 240                 if( IDocumentRedlineAccess::IsRedlineOn( GetRedlineFlags() ))
 241                     pTmpDoc->getIDocumentRedlineAccess().DeleteRedline( aPaM, true, RedlineType::Any );
 242                 if (m_bWithRsid)
 243                 {
 244                     // RSID was added: remove any CHARFMT/AUTOFMT that may be
 245                     // set on the deleted text; EraseText will leave empty
 246                     // ones behind otherwise
 247                     pTextNode->DeleteAttributes(RES_TXTATR_AUTOFMT,
 248                         aPaM.GetPoint()->GetContentIndex(),
 249                         aPaM.GetMark()->GetContentIndex());
 250                     pTextNode->DeleteAttributes(RES_TXTATR_CHARFMT,
 251                         aPaM.GetPoint()->GetContentIndex(),
 252                         aPaM.GetMark()->GetContentIndex());
 253                 }
 254                 RemoveIdxFromRange( aPaM, false );
 255                 maText = pTextNode->GetText().copy(m_nContent-m_nLen, m_nLen);
 256                 pTextNode->EraseText( *aPaM.GetPoint(), m_nLen );
 257             }
 258             else                // otherwise Graphics/OLE/Text/...
 259             {
 260                 aPaM.Move(fnMoveBackward);
 261                 if( IDocumentRedlineAccess::IsRedlineOn( GetRedlineFlags() ))
 262                     pTmpDoc->getIDocumentRedlineAccess().DeleteRedline( aPaM, true, RedlineType::Any );
 263                 RemoveIdxFromRange( aPaM, false );
 264             }
 265
 266             nNd = aPaM.GetPoint()->GetNodeIndex();
 267             nCnt = aPaM.GetPoint()->GetContentIndex();
 268
 269             if (!maText)
 270             {
 271                 m_oUndoNodeIndex.emplace(m_pDoc->GetNodes().GetEndOfContent());
 272                 MoveToUndoNds(aPaM, &*m_oUndoNodeIndex);
 273             }
 274             m_nNode = aPaM.GetPoint()->GetNodeIndex();
 275             m_nContent = aPaM.GetPoint()->GetContentIndex();
 276         }
 277
 278         // set cursor to Undo range
 279         pPam->DeleteMark();
 280
 281         pPam->GetPoint()->Assign( nNd, nCnt );
 282     }
 283
 284     maUndoText.reset();
 285 }
 286
 287 void SwUndoInsert::RedoImpl(::sw::UndoRedoContext & rContext)
 288 {
 289     SwDoc *const pTmpDoc = & rContext.GetDoc();
 290     SwCursor *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
 291     pPam->DeleteMark();
 292
 293     if( m_bIsAppend )
 294     {
 295         pPam->GetPoint()->Assign( m_nNode - 1 );
 296         pTmpDoc->getIDocumentContentOperations().AppendTextNode( *pPam->GetPoint() );
 297
 298         pPam->SetMark();
 299         pPam->Move( fnMoveBackward );
 300         pPam->Exchange();
 301
 302         if( m_pRedlData && IDocumentRedlineAccess::IsRedlineOn( GetRedlineFlags() ))
 303         {
 304             RedlineFlags eOld = pTmpDoc->getIDocumentRedlineAccess().GetRedlineFlags();
 305             pTmpDoc->getIDocumentRedlineAccess().SetRedlineFlags_intern(eOld & ~RedlineFlags::Ignore);
 306             pTmpDoc->getIDocumentRedlineAccess().AppendRedline( new SwRangeRedline( *m_pRedlData, *pPam ), true);
 307             pTmpDoc->getIDocumentRedlineAccess().SetRedlineFlags_intern( eOld );
 308         }
 309         else if( !( RedlineFlags::Ignore & GetRedlineFlags() ) &&
 310                 !pTmpDoc->getIDocumentRedlineAccess().GetRedlineTable().empty() )
 311             pTmpDoc->getIDocumentRedlineAccess().SplitRedline( *pPam );
 312
 313         pPam->DeleteMark();
 314     }
 315     else
 316     {
 317         pPam->GetPoint()->Assign( m_nNode );
 318         SwContentNode *const pCNd =
 319             pPam->GetPoint()->GetNode().GetContentNode();
 320         pPam->GetPoint()->SetContent( m_nContent );
 321
 322         if( m_nLen )
 323         {
 324             ::std::optional<SwNodeIndex> oMvBkwrd = MovePtBackward(*pPam);
 325
 326             if (maText)
 327             {
 328                 SwTextNode *const pTextNode = pCNd->GetTextNode();
 329                 OSL_ENSURE( pTextNode, "where is my textnode ?" );
 330                 OUString const ins(
 331                     pTextNode->InsertText( *maText, *pPam->GetMark(),
 332                     m_nInsertFlags) );
 333                 assert(ins.getLength() == maText->getLength()); // must succeed
 334                 maText.reset();
 335                 if (m_bWithRsid) // re-insert RSID
 336                 {
 337                     SwPaM pam(*pPam->GetMark(), nullptr); // mark -> point
 338                     pTmpDoc->UpdateRsid(pam, ins.getLength());
 339                 }
 340             }
 341             else
 342             {
 343                 // re-insert content again (first detach m_oUndoNodeIndex!)
 344                 SwNodeOffset const nMvNd = m_oUndoNodeIndex->GetIndex();
 345                 m_oUndoNodeIndex.reset();
 346                 MoveFromUndoNds(*pTmpDoc, nMvNd, *pPam->GetMark());
 347             }
 348             m_nNode = pPam->GetMark()->GetNodeIndex();
 349             m_nContent = pPam->GetMark()->GetContentIndex();
 350
 351             MovePtForward(*pPam, ::std::move(oMvBkwrd));
 352             pPam->Exchange();
 353             if( m_pRedlData && IDocumentRedlineAccess::IsRedlineOn( GetRedlineFlags() ))
 354             {
 355                 RedlineFlags eOld = pTmpDoc->getIDocumentRedlineAccess().GetRedlineFlags();
 356                 pTmpDoc->getIDocumentRedlineAccess().SetRedlineFlags_intern(eOld & ~RedlineFlags::Ignore);
 357                 pTmpDoc->getIDocumentRedlineAccess().AppendRedline( new SwRangeRedline( *m_pRedlData,
 358                                             *pPam ), true);
 359                 pTmpDoc->getIDocumentRedlineAccess().SetRedlineFlags_intern( eOld );
 360             }
 361             else if( !( RedlineFlags::Ignore & GetRedlineFlags() ) &&
 362                     !pTmpDoc->getIDocumentRedlineAccess().GetRedlineTable().empty() )
 363                 pTmpDoc->getIDocumentRedlineAccess().SplitRedline(*pPam);
 364         }
 365     }
 366
 367     maUndoText = GetTextFromDoc();
 368 }
 369
 370 void SwUndoInsert::RepeatImpl(::sw::RepeatContext & rContext)
 371 {
 372     if( !m_nLen )
 373         return;
 374
 375     SwDoc & rDoc = rContext.GetDoc();
 376     SwNodeIndex aNd( rDoc.GetNodes(), m_nNode );
 377     SwContentNode* pCNd = aNd.GetNode().GetContentNode();
 378
 379     if( !m_bIsAppend && 1 == m_nLen )       // >1 than always Text, otherwise Graphics/OLE/Text/...
 380     {
 381         SwPaM aPaM( *pCNd, m_nContent );
 382         aPaM.SetMark();
 383         aPaM.Move(fnMoveBackward);
 384         pCNd = aPaM.GetPointContentNode();
 385     }
 386
 387 // What happens with the possible selected range ???
 388
 389     switch( pCNd->GetNodeType() )
 390     {
 391     case SwNodeType::Text:
 392         if( m_bIsAppend )
 393         {
 394             rDoc.getIDocumentContentOperations().AppendTextNode( *rContext.GetRepeatPaM().GetPoint() );
 395         }
 396         else
 397         {
 398             OUString const aText( pCNd->GetTextNode()->GetText() );
 399             ::sw::GroupUndoGuard const undoGuard(rDoc.GetIDocumentUndoRedo());
 400             rDoc.getIDocumentContentOperations().InsertString( rContext.GetRepeatPaM(),
 401                 aText.copy(m_nContent - m_nLen, m_nLen) );
 402         }
 403         break;
 404     case SwNodeType::Grf:
 405         {
 406             SwGrfNode* pGrfNd = static_cast<SwGrfNode*>(pCNd);
 407             OUString sFile;
 408             OUString sFilter;
 409             if( pGrfNd->IsGrfLink() )
 410                 pGrfNd->GetFileFilterNms( &sFile, &sFilter );
 411
 412             rDoc.getIDocumentContentOperations().InsertGraphic(
 413                                 rContext.GetRepeatPaM(), sFile, sFilter,
 414                                 &pGrfNd->GetGrf(),
 415                                 nullptr/* Graphics collection*/, nullptr, nullptr );
 416         }
 417         break;
 418
 419     case SwNodeType::Ole:
 420         {
 421             // StarView does not yet provide an option to copy a StarOBJ
 422             SwOLEObj& rSwOLE = static_cast<SwOLENode*>(pCNd)->GetOLEObj();
 423
 424             // temporary storage until object is inserted
 425             // TODO/MBA: seems that here a physical copy is done - not as in drawing layer! Testing!
 426             // TODO/LATER: Copying through the container would copy the replacement image as well
 427             comphelper::EmbeddedObjectContainer aCnt;
 428             OUString aName = aCnt.CreateUniqueObjectName();
 429             if (aCnt.StoreEmbeddedObject(rSwOLE.GetOleRef(), aName, true, OUString(), OUString()))
 430             {
 431                 uno::Reference < embed::XEmbeddedObject > aNew = aCnt.GetEmbeddedObject( aName );
 432                 rDoc.getIDocumentContentOperations().InsertEmbObject(
 433                     rContext.GetRepeatPaM(),
 434                     svt::EmbeddedObjectRef( aNew,
 435                         static_cast<SwOLENode*>(pCNd)->GetAspect() ),
 436                     nullptr );
 437             }
 438
 439             break;
 440         }
 441
 442     default: break;
 443     }
 444 }
 445
 446 SwRewriter SwUndoInsert::GetRewriter() const
 447 {
 448     SwRewriter aResult;
 449     std::optional<OUString> aStr;
 450     bool bDone = false;
 451
 452     if (maText)
 453         aStr = maText;
 454     else if (maUndoText)
 455         aStr = maUndoText;
 456
 457     if (aStr)
 458     {
 459         OUString aString = ShortenString(DenoteSpecialCharacters(*aStr),
 460                                        nUndoStringLength,
 461                                        SwResId(STR_LDOTS));
 462
 463         aResult.AddRule(UndoArg1, aString);
 464
 465         bDone = true;
 466     }
 467
 468     if ( ! bDone )
 469     {
 470         aResult.AddRule(UndoArg1, "??");
 471     }
 472
 473     return aResult;
 474 }
 475
 476 bool SwUndoInsert::IsIndependent(const SwUndoInsert& rOther) const
 477 {
 478     return m_nNode != rOther.m_nNode;
 479 }
 480
 481 class SwUndoReplace::Impl
 482     : private SwUndoSaveContent
 483 {
 484     OUString m_sOld;
 485     OUString m_sIns;
 486     SwNodeOffset m_nSttNd, m_nEndNd, m_nOffset;
 487     sal_Int32 m_nSttCnt, m_nEndCnt, m_nSetPos, m_nSelEnd;
 488     bool m_bSplitNext : 1;
 489     bool m_bRegExp : 1;
 490     // metadata references for paragraph and following para (if m_bSplitNext)
 491     std::shared_ptr< ::sfx2::MetadatableUndo > m_pMetadataUndoStart;
 492     std::shared_ptr< ::sfx2::MetadatableUndo > m_pMetadataUndoEnd;
 493
 494 public:
 495     Impl(SwPaM const& rPam, OUString aIns, bool const bRegExp);
 496
 497     void UndoImpl( ::sw::UndoRedoContext & );
 498     void RedoImpl( ::sw::UndoRedoContext & );
 499
 500     void SetEnd(SwPaM const& rPam);
 501
 502     OUString const& GetOld() const { return m_sOld; }
 503     OUString const& GetIns() const { return m_sIns; }
 504 };
 505
 506 SwUndoReplace::SwUndoReplace(SwPaM const& rPam,
 507         OUString const& rIns, bool const bRegExp)
 508     : SwUndo( SwUndoId::REPLACE, &rPam.GetDoc() )
 509     , m_pImpl(std::make_unique<Impl>(rPam, rIns, bRegExp))
 510 {
 511 }
 512
 513 SwUndoReplace::~SwUndoReplace()
 514 {
 515 }
 516
 517 void SwUndoReplace::UndoImpl(::sw::UndoRedoContext & rContext)
 518 {
 519     m_pImpl->UndoImpl(rContext);
 520 }
 521
 522 void SwUndoReplace::RedoImpl(::sw::UndoRedoContext & rContext)
 523 {
 524     m_pImpl->RedoImpl(rContext);
 525 }
 526
 527 SwRewriter
 528 MakeUndoReplaceRewriter(sal_uLong const occurrences,
 529         OUString const& sOld, OUString const& sNew)
 530 {
 531     SwRewriter aResult;
 532
 533     if (1 < occurrences)
 534     {
 535         aResult.AddRule(UndoArg1, OUString::number(occurrences));
 536         aResult.AddRule(UndoArg2, SwResId(STR_OCCURRENCES_OF));
 537
 538         OUString aTmpStr =
 539             SwResId(STR_START_QUOTE)
 540             + ShortenString(sOld, nUndoStringLength, SwResId(STR_LDOTS))
 541             + SwResId(STR_END_QUOTE);
 542         aResult.AddRule(UndoArg3, aTmpStr);
 543     }
 544     else if (1 == occurrences)
 545     {
 546         {
 547             // #i33488 #
 548             OUString aTmpStr =
 549                 SwResId(STR_START_QUOTE)
 550                 + ShortenString(sOld, nUndoStringLength, SwResId(STR_LDOTS))
 551                 + SwResId(STR_END_QUOTE);
 552             aResult.AddRule(UndoArg1, aTmpStr);
 553         }
 554
 555         aResult.AddRule(UndoArg2, SwResId(STR_YIELDS));
 556
 557         {
 558             // #i33488 #
 559             OUString aTmpStr =
 560                 SwResId(STR_START_QUOTE)
 561                 + ShortenString(sNew, nUndoStringLength, SwResId(STR_LDOTS))
 562                 + SwResId(STR_END_QUOTE);
 563             aResult.AddRule(UndoArg3, aTmpStr);
 564         }
 565     }
 566
 567     return aResult;
 568 }
 569
 570 SwRewriter SwUndoReplace::GetRewriter() const
 571 {
 572     return MakeUndoReplaceRewriter(1, m_pImpl->GetOld(), m_pImpl->GetIns());
 573 }
 574
 575 void SwUndoReplace::SetEnd(SwPaM const& rPam)
 576 {
 577     m_pImpl->SetEnd(rPam);
 578 }
 579
 580 SwUndoReplace::Impl::Impl(
 581         SwPaM const& rPam, OUString aIns, bool const bRegExp)
 582     : m_sIns(std::move( aIns ))
 583     , m_nOffset( 0 )
 584     , m_bRegExp(bRegExp)
 585 {
 586
 587     auto [pStt, pEnd] = rPam.StartEnd(); // SwPosition*
 588
 589     m_nSttNd = m_nEndNd = pStt->GetNodeIndex();
 590     m_nSttCnt = pStt->GetContentIndex();
 591     m_nSelEnd = m_nEndCnt = pEnd->GetContentIndex();
 592
 593     m_bSplitNext = m_nSttNd != pEnd->GetNodeIndex();
 594
 595     SwTextNode* pNd = pStt->GetNode().GetTextNode();
 596     OSL_ENSURE( pNd, "Dude, where's my TextNode?" );
 597
 598     m_pHistory.reset( new SwHistory );
 599     DelContentIndex(*rPam.GetMark(), *rPam.GetPoint(), DelContentType::AllMask | DelContentType::Replace);
 600
 601     m_nSetPos = m_pHistory->Count();
 602
 603     SwNodeOffset nNewPos = pStt->GetNodeIndex();
 604     m_nOffset = m_nSttNd - nNewPos;
 605
 606     if ( pNd->GetpSwpHints() )
 607     {
 608         m_pHistory->CopyAttr( pNd->GetpSwpHints(), nNewPos, 0,
 609                             pNd->GetText().getLength(), true );
 610     }
 611
 612     if ( m_bSplitNext )
 613     {
 614         if( pNd->HasSwAttrSet() )
 615             m_pHistory->CopyFormatAttr( *pNd->GetpSwAttrSet(), nNewPos );
 616         m_pHistory->Add( pNd->GetTextColl(), nNewPos, SwNodeType::Text );
 617
 618         SwTextNode* pNext = pEnd->GetNode().GetTextNode();
 619         SwNodeOffset nTmp = pNext->GetIndex();
 620         m_pHistory->CopyAttr( pNext->GetpSwpHints(), nTmp, 0,
 621                             pNext->GetText().getLength(), true );
 622         if( pNext->HasSwAttrSet() )
 623             m_pHistory->CopyFormatAttr( *pNext->GetpSwAttrSet(), nTmp );
 624         m_pHistory->Add( pNext->GetTextColl(),nTmp, SwNodeType::Text );
 625         // METADATA: store
 626         m_pMetadataUndoStart = pNd  ->CreateUndo();
 627         m_pMetadataUndoEnd   = pNext->CreateUndo();
 628     }
 629
 630     if( !m_pHistory->Count() )
 631     {
 632         m_pHistory.reset();
 633     }
 634
 635     const sal_Int32 nECnt = m_bSplitNext ? pNd->GetText().getLength()
 636         : pEnd->GetContentIndex();
 637     m_sOld = pNd->GetText().copy( m_nSttCnt, nECnt - m_nSttCnt );
 638 }
 639
 640 void SwUndoReplace::Impl::UndoImpl(::sw::UndoRedoContext & rContext)
 641 {
 642     SwDoc *const pDoc = & rContext.GetDoc();
 643     SwCursor & rPam(rContext.GetCursorSupplier().CreateNewShellCursor());
 644     rPam.DeleteMark();
 645
 646     SwTextNode* pNd = pDoc->GetNodes()[ m_nSttNd - m_nOffset ]->GetTextNode();
 647     OSL_ENSURE( pNd, "Dude, where's my TextNode?" );
 648
 649     SwAutoCorrExceptWord* pACEWord = pDoc->GetAutoCorrExceptWord();
 650     if( pACEWord )
 651     {
 652         if ((1 == m_sIns.getLength()) && (1 == m_sOld.getLength()))
 653         {
 654             SwPosition aPos( *pNd, m_nSttCnt );
 655             pACEWord->CheckChar( aPos, m_sOld[ 0 ] );
 656         }
 657         pDoc->SetAutoCorrExceptWord( nullptr );
 658     }
 659
 660     // don't look at m_sIns for deletion, maybe it was not completely inserted
 661     {
 662         rPam.GetPoint()->Assign(*pNd, m_nSttCnt );
 663         rPam.SetMark();
 664         rPam.GetPoint()->Assign( m_nSttNd - m_nOffset, m_nSttNd == m_nEndNd ? m_nEndCnt : pNd->Len());
 665
 666         // replace only in start node, without regex
 667         bool const ret = pDoc->getIDocumentContentOperations().ReplaceRange(rPam, m_sOld, false);
 668         assert(ret); (void)ret;
 669         if (m_nSttNd != m_nEndNd)
 670         {   // in case of regex inserting paragraph breaks, join nodes...
 671             assert(rPam.GetMark()->GetContentIndex() == rPam.GetMark()->GetNode().GetTextNode()->Len());
 672             rPam.GetPoint()->Assign( m_nEndNd - m_nOffset, m_nEndCnt );
 673             pDoc->getIDocumentContentOperations().DeleteAndJoin(rPam);
 674         }
 675         rPam.DeleteMark();
 676         pNd = pDoc->GetNodes()[ m_nSttNd - m_nOffset ]->GetTextNode();
 677         OSL_ENSURE( pNd, "Dude, where's my TextNode?" );
 678     }
 679
 680     if( m_bSplitNext )
 681     {
 682         assert(m_nSttCnt + m_sOld.getLength() <= pNd->Len());
 683         SwPosition aPos(*pNd, m_nSttCnt + m_sOld.getLength());
 684         pDoc->getIDocumentContentOperations().SplitNode( aPos, false );
 685         pNd->RestoreMetadata(m_pMetadataUndoEnd);
 686         pNd = pDoc->GetNodes()[ m_nSttNd - m_nOffset ]->GetTextNode();
 687         // METADATA: restore
 688         pNd->RestoreMetadata(m_pMetadataUndoStart);
 689     }
 690
 691     if( m_pHistory )
 692     {
 693         if( pNd->GetpSwpHints() )
 694             pNd->ClearSwpHintsArr( true );
 695
 696         m_pHistory->TmpRollback( pDoc, m_nSetPos, false );
 697         if ( m_nSetPos ) // there were footnotes/FlyFrames
 698         {
 699             // are there others than these?
 700             if( m_nSetPos < m_pHistory->Count() )
 701             {
 702                 // than save those attributes as well
 703                 SwHistory aHstr;
 704                 aHstr.Move( 0, m_pHistory.get(), m_nSetPos );
 705                 m_pHistory->Rollback( pDoc );
 706                 m_pHistory->Move( 0, &aHstr );
 707             }
 708             else
 709             {
 710                 m_pHistory->Rollback( pDoc );
 711                 m_pHistory.reset();
 712             }
 713         }
 714     }
 715
 716     rPam.GetPoint()->Assign( m_nSttNd, m_nSttCnt );
 717 }
 718
 719 void SwUndoReplace::Impl::RedoImpl(::sw::UndoRedoContext & rContext)
 720 {
 721     SwDoc & rDoc = rContext.GetDoc();
 722     SwCursor & rPam(rContext.GetCursorSupplier().CreateNewShellCursor());
 723     rPam.DeleteMark();
 724     rPam.GetPoint()->Assign( m_nSttNd, m_nSttCnt );
 725
 726     rPam.SetMark();
 727     if( m_bSplitNext )
 728         rPam.GetPoint()->Assign( m_nSttNd + 1 );
 729     rPam.GetPoint()->SetContent( m_nSelEnd );
 730
 731     if( m_pHistory )
 732     {
 733         auto xSave = std::make_unique<SwHistory>();
 734         std::swap(m_pHistory, xSave);
 735
 736         DelContentIndex(*rPam.GetMark(), *rPam.GetPoint(), DelContentType::AllMask | DelContentType::Replace);
 737         m_nSetPos = m_pHistory->Count();
 738
 739         std::swap(xSave, m_pHistory);
 740         m_pHistory->Move(0, xSave.get());
 741     }
 742     else
 743     {
 744         m_pHistory.reset( new SwHistory );
 745         DelContentIndex(*rPam.GetMark(), *rPam.GetPoint(), DelContentType::AllMask | DelContentType::Replace);
 746         m_nSetPos = m_pHistory->Count();
 747         if( !m_nSetPos )
 748         {
 749             m_pHistory.reset();
 750         }
 751     }
 752
 753     rDoc.getIDocumentContentOperations().ReplaceRange( rPam, m_sIns, m_bRegExp );
 754     rPam.DeleteMark();
 755 }
 756
 757 void SwUndoReplace::Impl::SetEnd(SwPaM const& rPam)
 758 {
 759     const SwPosition* pEnd = rPam.End();
 760     m_nEndNd = m_nOffset + pEnd->GetNodeIndex();
 761     m_nEndCnt = pEnd->GetContentIndex();
 762 }
 763
 764 SwUndoReRead::SwUndoReRead( const SwPaM& rPam, const SwGrfNode& rGrfNd )
 765     : SwUndo( SwUndoId::REREAD, &rPam.GetDoc() ), mnPosition( rPam.GetPoint()->GetNodeIndex() )
 766 {
 767     SaveGraphicData( rGrfNd );
 768 }
 769
 770 SwUndoReRead::~SwUndoReRead()
 771 {
 772 }
 773
 774 void SwUndoReRead::SetAndSave(::sw::UndoRedoContext & rContext)
 775 {
 776     SwDoc & rDoc = rContext.GetDoc();
 777     SwGrfNode* pGrfNd = rDoc.GetNodes()[ mnPosition ]->GetGrfNode();
 778
 779     if( !pGrfNd )
 780         return ;
 781
 782     // cache the old values
 783     std::optional<Graphic> oOldGrf(moGraphic);
 784     std::optional<OUString> aOldNm = maNm;
 785     MirrorGraph nOldMirr = mnMirror;
 786     // since all of them are cleared/modified by SaveGraphicData:
 787     SaveGraphicData( *pGrfNd );
 788
 789     if( aOldNm )
 790     {
 791         pGrfNd->ReRead( *aOldNm, maFltr ? *maFltr : OUString() );
 792     }
 793     else
 794     {
 795         pGrfNd->ReRead( OUString(), OUString(), oOldGrf ? &*oOldGrf : nullptr );
 796     }
 797
 798     if( MirrorGraph::Dont != nOldMirr )
 799         pGrfNd->SetAttr( SwMirrorGrf() );
 800
 801     rContext.SetSelections(pGrfNd->GetFlyFormat(), nullptr);
 802 }
 803
 804 void SwUndoReRead::UndoImpl(::sw::UndoRedoContext & rContext)
 805 {
 806     SetAndSave(rContext);
 807 }
 808
 809 void SwUndoReRead::RedoImpl(::sw::UndoRedoContext & rContext)
 810 {
 811     SetAndSave(rContext);
 812 }
 813
 814 void SwUndoReRead::SaveGraphicData( const SwGrfNode& rGrfNd )
 815 {
 816     if( rGrfNd.IsGrfLink() )
 817     {
 818         maNm = OUString();
 819         maFltr = OUString();
 820         rGrfNd.GetFileFilterNms(&*maNm, &*maFltr);
 821         moGraphic.reset();
 822     }
 823     else
 824     {
 825         moGraphic.emplace( rGrfNd.GetGrf(true) );
 826         maNm.reset();
 827         maFltr.reset();
 828     }
 829     mnMirror = rGrfNd.GetSwAttrSet().GetMirrorGrf().GetValue();
 830 }
 831
 832 SwUndoInsertLabel::SwUndoInsertLabel( const SwLabelType eTyp,
 833                                       OUString aText,
 834                                       OUString aSeparator,
 835                                       OUString aNumberSeparator,
 836                                       const bool bBef,
 837                                       const sal_uInt16 nInitId,
 838                                       OUString aCharacterStyle,
 839                                       const bool bCpyBorder,
 840                                       const SwDoc* pDoc )
 841     : SwUndo( SwUndoId::INSERTLABEL, pDoc ),
 842       m_sText(std::move( aText )),
 843       m_sSeparator(std::move( aSeparator )),
 844       m_sNumberSeparator(std::move( aNumberSeparator )),//#i61007# order of captions
 845       m_sCharacterStyle(std::move( aCharacterStyle )),
 846       m_nFieldId( nInitId ),
 847       m_eType( eTyp ),
 848       m_nLayerId( 0 ),
 849       m_bBefore( bBef ),
 850       m_bCopyBorder( bCpyBorder )
 851 {
 852     m_bUndoKeep = false;
 853     OBJECT.pUndoFly = nullptr;
 854     OBJECT.pUndoAttr = nullptr;
 855 }
 856
 857 SwUndoInsertLabel::~SwUndoInsertLabel()
 858 {
 859     if( SwLabelType::Object == m_eType || SwLabelType::Draw == m_eType )
 860     {
 861         delete OBJECT.pUndoFly;
 862         delete OBJECT.pUndoAttr;
 863     }
 864     else
 865         delete NODE.pUndoInsNd;
 866 }
 867
 868 void SwUndoInsertLabel::UndoImpl(::sw::UndoRedoContext & rContext)
 869 {
 870     SwDoc & rDoc = rContext.GetDoc();
 871
 872     if( SwLabelType::Object == m_eType || SwLabelType::Draw == m_eType )
 873     {
 874         OSL_ENSURE( OBJECT.pUndoAttr && OBJECT.pUndoFly, "Pointer not initialized" );
 875         SwFrameFormat* pFormat;
 876         SdrObject *pSdrObj = nullptr;
 877         if( OBJECT.pUndoAttr &&
 878             nullptr != (pFormat = static_cast<SwFrameFormat*>(OBJECT.pUndoAttr->GetFormat( rDoc ))) &&
 879             ( SwLabelType::Draw != m_eType ||
 880               nullptr != (pSdrObj = pFormat->FindSdrObject()) ) )
 881         {
 882             OBJECT.pUndoAttr->UndoImpl(rContext);
 883             OBJECT.pUndoFly->UndoImpl(rContext);
 884             if( SwLabelType::Draw == m_eType )
 885             {
 886                 pSdrObj->SetLayer( m_nLayerId );
 887             }
 888         }
 889     }
 890     else if( NODE.nNode )
 891     {
 892         if ( m_eType == SwLabelType::Table && m_bUndoKeep )
 893         {
 894             SwTableNode *pNd = rDoc.GetNodes()[
 895                         rDoc.GetNodes()[NODE.nNode-1]->StartOfSectionIndex()]->GetTableNode();
 896             if ( pNd )
 897                 pNd->GetTable().GetFrameFormat()->ResetFormatAttr( RES_KEEP );
 898         }
 899         SwPaM aPam( rDoc.GetNodes().GetEndOfContent() );
 900         aPam.GetPoint()->Assign( NODE.nNode );
 901         aPam.SetMark();
 902         aPam.GetPoint()->Assign( NODE.nNode + 1 );
 903         NODE.pUndoInsNd = new SwUndoDelete(aPam, SwDeleteFlags::Default, true);
 904     }
 905 }
 906
 907 void SwUndoInsertLabel::RedoImpl(::sw::UndoRedoContext & rContext)
 908 {
 909     SwDoc & rDoc = rContext.GetDoc();
 910
 911     if( SwLabelType::Object == m_eType || SwLabelType::Draw == m_eType )
 912     {
 913         OSL_ENSURE( OBJECT.pUndoAttr && OBJECT.pUndoFly, "Pointer not initialized" );
 914         SwFrameFormat* pFormat;
 915         SdrObject *pSdrObj = nullptr;
 916         if( OBJECT.pUndoAttr &&
 917             nullptr != (pFormat = static_cast<SwFrameFormat*>(OBJECT.pUndoAttr->GetFormat( rDoc ))) &&
 918             ( SwLabelType::Draw != m_eType ||
 919               nullptr != (pSdrObj = pFormat->FindSdrObject()) ) )
 920         {
 921             OBJECT.pUndoFly->RedoImpl(rContext);
 922             OBJECT.pUndoAttr->RedoImpl(rContext);
 923             if( SwLabelType::Draw == m_eType )
 924             {
 925                 pSdrObj->SetLayer( m_nLayerId );
 926                 if( pSdrObj->GetLayer() == rDoc.getIDocumentDrawModelAccess().GetHellId() )
 927                     pSdrObj->SetLayer( rDoc.getIDocumentDrawModelAccess().GetHeavenId() );
 928                 // OD 02.07.2003 #108784#
 929                 else if( pSdrObj->GetLayer() == rDoc.getIDocumentDrawModelAccess().GetInvisibleHellId() )
 930                     pSdrObj->SetLayer( rDoc.getIDocumentDrawModelAccess().GetInvisibleHeavenId() );
 931             }
 932         }
 933     }
 934     else if( NODE.pUndoInsNd )
 935     {
 936         if ( m_eType == SwLabelType::Table && m_bUndoKeep )
 937         {
 938             SwTableNode *pNd = rDoc.GetNodes()[
 939                         rDoc.GetNodes()[NODE.nNode-1]->StartOfSectionIndex()]->GetTableNode();
 940             if ( pNd )
 941                 pNd->GetTable().GetFrameFormat()->SetFormatAttr( SvxFormatKeepItem(true, RES_KEEP) );
 942         }
 943         NODE.pUndoInsNd->UndoImpl(rContext);
 944         delete NODE.pUndoInsNd;
 945         NODE.pUndoInsNd = nullptr;
 946     }
 947 }
 948
 949 void SwUndoInsertLabel::RepeatImpl(::sw::RepeatContext & rContext)
 950 {
 951     SwDoc & rDoc = rContext.GetDoc();
 952     const SwPosition& rPos = *rContext.GetRepeatPaM().GetPoint();
 953
 954     SwNodeOffset nIdx(0);
 955
 956     SwContentNode* pCNd = rPos.GetNode().GetContentNode();
 957     if( pCNd )
 958         switch( m_eType )
 959         {
 960         case SwLabelType::Table:
 961             {
 962                 const SwTableNode* pTNd = pCNd->FindTableNode();
 963                 if( pTNd )
 964                     nIdx = pTNd->GetIndex();
 965             }
 966             break;
 967
 968         case SwLabelType::Fly:
 969         case SwLabelType::Object:
 970             {
 971                 SwFlyFrame* pFly;
 972                 SwContentFrame *pCnt = pCNd->getLayoutFrame( rDoc.getIDocumentLayoutAccess().GetCurrentLayout() );
 973                 if( pCnt && nullptr != ( pFly = pCnt->FindFlyFrame() ) )
 974                     nIdx = pFly->GetFormat()->GetContent().GetContentIdx()->GetIndex();
 975             }
 976             break;
 977         case SwLabelType::Draw:
 978             break;
 979         }
 980
 981     if( nIdx )
 982     {
 983         rDoc.InsertLabel( m_eType, m_sText, m_sSeparator, m_sNumberSeparator, m_bBefore,
 984             m_nFieldId, nIdx, m_sCharacterStyle, m_bCopyBorder );
 985     }
 986 }
 987
 988 SwRewriter SwUndoInsertLabel::GetRewriter() const
 989 {
 990     return CreateRewriter(m_sText);
 991 }
 992
 993 SwRewriter SwUndoInsertLabel::CreateRewriter(const OUString &rStr)
 994 {
 995     SwRewriter aRewriter;
 996
 997     OUString aTmpStr;
 998
 999     if (!rStr.isEmpty())
1000     {
1001         aTmpStr =
1002             SwResId(STR_START_QUOTE)
1003             + ShortenString(rStr, nUndoStringLength, SwResId(STR_LDOTS))
1004             + SwResId(STR_END_QUOTE);
1005     }
1006
1007     aRewriter.AddRule(UndoArg1, aTmpStr);
1008
1009     return aRewriter;
1010 }
1011
1012 void SwUndoInsertLabel::SetFlys( SwFrameFormat& rOldFly, SfxItemSet const & rChgSet,
1013                                 SwFrameFormat& rNewFly )
1014 {
1015     if( SwLabelType::Object == m_eType || SwLabelType::Draw == m_eType )
1016     {
1017         SwUndoFormatAttrHelper aTmp( rOldFly, false );
1018         rOldFly.SetFormatAttr( rChgSet );
1019         if ( aTmp.GetUndo() )
1020         {
1021             OBJECT.pUndoAttr = aTmp.ReleaseUndo().release();
1022         }
1023         OBJECT.pUndoFly = new SwUndoInsLayFormat( &rNewFly, SwNodeOffset(0), 0 );
1024     }
1025 }
1026
1027 void SwUndoInsertLabel::SetDrawObj( SdrLayerID nLId )
1028 {
1029     if( SwLabelType::Draw == m_eType )
1030     {
1031         m_nLayerId = nLId;
1032     }
1033 }
1034
1035 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */