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
  21 #include <UndoInsert.hxx>
  22
  23 #include <hintids.hxx>
  24 #include <unotools/charclass.hxx>
  25 #include <sot/storage.hxx>
  26 #include <editeng/keepitem.hxx>
  27 #include <svx/svdobj.hxx>
  28 #include <xmloff/odffields.hxx>
  29
  30 #include <docsh.hxx>
  31 #include <fmtcntnt.hxx>
  32 #include <fmtanchr.hxx>
  33 #include <frmfmt.hxx>
  34 #include <doc.hxx>
  35 #include <IDocumentUndoRedo.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 <fesh.hxx>
  49 #include <swtable.hxx>
  50 #include <redline.hxx>
  51 #include <docary.hxx>
  52 #include <acorrect.hxx>
  53 #include <dcontact.hxx>
  54
  55 #include <comcore.hrc> // #111827#
  56 #include <undo.hrc>
  57
  58 using namespace ::com::sun::star;
  59
  60
  61 //------------------------------------------------------------
  62
  63 // INSERT
  64
  65 String * SwUndoInsert::GetTxtFromDoc() const
  66 {
  67     String * pResult = NULL;
  68
  69     SwNodeIndex aNd( pDoc->GetNodes(), nNode);
  70     SwCntntNode* pCNd = aNd.GetNode().GetCntntNode();
  71     SwPaM aPaM( *pCNd, nCntnt );
  72
  73     aPaM.SetMark();
  74
  75     if( pCNd->IsTxtNode() )
  76     {
  77         pResult = new String( ((SwTxtNode*)pCNd)->GetTxt().Copy(nCntnt-nLen,
  78                                                              nLen ) );
  79
  80     }
  81
  82     return pResult;
  83 }
  84
  85 void SwUndoInsert::Init(const SwNodeIndex & rNd)
  86 {
  87     // consider Redline
  88     pDoc = rNd.GetNode().GetDoc();
  89     if( pDoc->IsRedlineOn() )
  90     {
  91         pRedlData = new SwRedlineData( nsRedlineType_t::REDLINE_INSERT,
  92                                        pDoc->GetRedlineAuthor() );
  93         SetRedlineMode( pDoc->GetRedlineMode() );
  94     }
  95
  96     pUndoTxt = GetTxtFromDoc();
  97
  98     bCacheComment = false;
  99 }
 100
 101 // #111827#
 102 SwUndoInsert::SwUndoInsert( const SwNodeIndex& rNd, xub_StrLen nCnt,
 103             xub_StrLen nL,
 104             const IDocumentContentOperations::InsertFlags nInsertFlags,
 105             sal_Bool bWDelim )
 106     : SwUndo(UNDO_TYPING), pPos( 0 ), pTxt( 0 ), pRedlData( 0 ),
 107         nNode( rNd.GetIndex() ), nCntnt(nCnt), nLen(nL),
 108         bIsWordDelim( bWDelim ), bIsAppend( sal_False )
 109     , m_nInsertFlags(nInsertFlags)
 110 {
 111     Init(rNd);
 112 }
 113
 114 // #111827#
 115 SwUndoInsert::SwUndoInsert( const SwNodeIndex& rNd )
 116     : SwUndo(UNDO_SPLITNODE), pPos( 0 ), pTxt( 0 ),
 117         pRedlData( 0 ), nNode( rNd.GetIndex() ), nCntnt(0), nLen(1),
 118         bIsWordDelim( sal_False ), bIsAppend( sal_True )
 119     , m_nInsertFlags(IDocumentContentOperations::INS_EMPTYEXPAND)
 120 {
 121     Init(rNd);
 122 }
 123
 124 // Check if the next Insert can be combined with the current one. If so
 125 // change the length and InsPos. As a result, SwDoc::Inser will not add a
 126 // new object into the Undo list.
 127
 128 sal_Bool SwUndoInsert::CanGrouping( sal_Unicode cIns )
 129 {
 130     if( !bIsAppend && bIsWordDelim ==
 131         !GetAppCharClass().isLetterNumeric( rtl::OUString( cIns )) )
 132     {
 133         nLen++;
 134         nCntnt++;
 135
 136         if (pUndoTxt)
 137             pUndoTxt->Insert(cIns);
 138
 139         return sal_True;
 140     }
 141     return sal_False;
 142 }
 143
 144 sal_Bool SwUndoInsert::CanGrouping( const SwPosition& rPos )
 145 {
 146     sal_Bool bRet = sal_False;
 147     if( nNode == rPos.nNode.GetIndex() &&
 148         nCntnt == rPos.nContent.GetIndex() )
 149     {
 150         // consider Redline
 151         SwDoc& rDoc = *rPos.nNode.GetNode().GetDoc();
 152         if( ( ~nsRedlineMode_t::REDLINE_SHOW_MASK & rDoc.GetRedlineMode() ) ==
 153             ( ~nsRedlineMode_t::REDLINE_SHOW_MASK & GetRedlineMode() ) )
 154         {
 155             bRet = sal_True;
 156
 157             // than there is or was still an active Redline:
 158             // Check if there is another Redline at the InsPosition. If the
 159             // same exists only once, it can be combined.
 160             const SwRedlineTbl& rTbl = rDoc.GetRedlineTbl();
 161             if( !rTbl.empty() )
 162             {
 163                 SwRedlineData aRData( nsRedlineType_t::REDLINE_INSERT, rDoc.GetRedlineAuthor() );
 164                 const SwIndexReg* pIReg = rPos.nContent.GetIdxReg();
 165                 SwIndex* pIdx;
 166                 for( sal_uInt16 i = 0; i < rTbl.size(); ++i )
 167                 {
 168                     SwRedline* pRedl = rTbl[ i ];
 169                     if( pIReg == (pIdx = &pRedl->End()->nContent)->GetIdxReg() &&
 170                         nCntnt == pIdx->GetIndex() )
 171                     {
 172                         if( !pRedl->HasMark() || !pRedlData ||
 173                             *pRedl != *pRedlData || *pRedl != aRData )
 174                         {
 175                             bRet = sal_False;
 176                             break;
 177                         }
 178                     }
 179                 }
 180             }
 181         }
 182     }
 183     return bRet;
 184 }
 185
 186 SwUndoInsert::~SwUndoInsert()
 187 {
 188     if( pPos )      // delete the section from UndoNodes array
 189     {
 190         // Insert saves the content in IconSection
 191         SwNodes& rUNds = pPos->nNode.GetNode().GetNodes();
 192         if( pPos->nContent.GetIndex() )         // do not delete the whole node
 193         {
 194             SwTxtNode* pTxtNd = pPos->nNode.GetNode().GetTxtNode();
 195             OSL_ENSURE( pTxtNd, "no TextNode to delete from" );
 196             pTxtNd->EraseText( pPos->nContent );
 197             pPos->nNode++;
 198         }
 199         pPos->nContent.Assign( 0, 0 );
 200         rUNds.Delete( pPos->nNode, rUNds.GetEndOfExtras().GetIndex() -
 201                                     pPos->nNode.GetIndex() );
 202         delete pPos;
 203     }
 204     else if( pTxt )     // the inserted text
 205         delete pTxt;
 206     delete pRedlData;
 207     delete pUndoTxt;
 208 }
 209
 210
 211
 212 void SwUndoInsert::UndoImpl(::sw::UndoRedoContext & rContext)
 213 {
 214     SwDoc *const pTmpDoc = & rContext.GetDoc();
 215     SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
 216
 217     if( bIsAppend )
 218     {
 219         pPam->GetPoint()->nNode = nNode;
 220
 221         if( IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ))
 222         {
 223             pPam->GetPoint()->nContent.Assign( pPam->GetCntntNode(), 0 );
 224             pPam->SetMark();
 225             pPam->Move( fnMoveBackward );
 226             pPam->Exchange();
 227             pTmpDoc->DeleteRedline( *pPam, true, USHRT_MAX );
 228         }
 229         pPam->DeleteMark();
 230         pTmpDoc->DelFullPara( *pPam );
 231         pPam->GetPoint()->nContent.Assign( pPam->GetCntntNode(), 0 );
 232     }
 233     else
 234     {
 235         sal_uLong nNd = nNode;
 236         xub_StrLen nCnt = nCntnt;
 237         if( nLen )
 238         {
 239             SwNodeIndex aNd( pTmpDoc->GetNodes(), nNode);
 240             SwCntntNode* pCNd = aNd.GetNode().GetCntntNode();
 241             SwPaM aPaM( *pCNd, nCntnt );
 242
 243             aPaM.SetMark();
 244
 245             SwTxtNode * const pTxtNode( pCNd->GetTxtNode() );
 246             if ( pTxtNode )
 247             {
 248                 aPaM.GetPoint()->nContent -= nLen;
 249                 if( IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ))
 250                     pTmpDoc->DeleteRedline( aPaM, true, USHRT_MAX );
 251                 RemoveIdxFromRange( aPaM, sal_False );
 252                 pTxt = new String( pTxtNode->GetTxt().Copy(nCntnt-nLen, nLen) );
 253                 pTxtNode->EraseText( aPaM.GetPoint()->nContent, nLen );
 254
 255                 // Undo deletes fieldmarks in two step: first the end then the start position.
 256                 // Once the start position is deleted, make sure the fieldmark itself is deleted as well.
 257                 if (nLen == 1)
 258                 {
 259                     IDocumentMarkAccess* const pMarkAccess = pTmpDoc->getIDocumentMarkAccess();
 260                     for ( IDocumentMarkAccess::const_iterator_t i = pMarkAccess->getMarksBegin(); i != pMarkAccess->getMarksEnd(); ++i)
 261                     {
 262                         sw::mark::IMark* pMark = i->get();
 263                         if (pMark->GetMarkStart() == *aPaM.GetPoint() && pMark->GetMarkStart().nContent == aPaM.GetPoint()->nContent)
 264                         {
 265                             sw::mark::IFieldmark* pFieldmark = dynamic_cast<sw::mark::IFieldmark*>(pMark);
 266                             if (pFieldmark && pFieldmark->GetFieldname() == ODF_COMMENTRANGE)
 267                             {
 268                                 pTmpDoc->getIDocumentMarkAccess()->deleteMark(pMark);
 269                                 break;
 270                             }
 271                         }
 272                     }
 273                 }
 274             }
 275             else                // otherwise Graphics/OLE/Text/...
 276             {
 277                 aPaM.Move(fnMoveBackward);
 278                 if( IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ))
 279                     pTmpDoc->DeleteRedline( aPaM, true, USHRT_MAX );
 280                 RemoveIdxFromRange( aPaM, sal_False );
 281             }
 282
 283             nNd = aPaM.GetPoint()->nNode.GetIndex();
 284             nCnt = aPaM.GetPoint()->nContent.GetIndex();
 285
 286             if( !pTxt )
 287             {
 288                 pPos = new SwPosition( *aPaM.GetPoint() );
 289                 MoveToUndoNds( aPaM, &pPos->nNode, &pPos->nContent );
 290             }
 291             nNode = aPaM.GetPoint()->nNode.GetIndex();
 292             nCntnt = aPaM.GetPoint()->nContent.GetIndex();
 293         }
 294
 295         // set cursor to Undo range
 296         pPam->DeleteMark();
 297
 298         pPam->GetPoint()->nNode = nNd;
 299         pPam->GetPoint()->nContent.Assign(
 300                 pPam->GetPoint()->nNode.GetNode().GetCntntNode(), nCnt );
 301     }
 302
 303     DELETEZ(pUndoTxt);
 304 }
 305
 306
 307 void SwUndoInsert::RedoImpl(::sw::UndoRedoContext & rContext)
 308 {
 309     SwDoc *const pTmpDoc = & rContext.GetDoc();
 310     SwPaM *const pPam(& rContext.GetCursorSupplier().CreateNewShellCursor());
 311     pPam->DeleteMark();
 312
 313     if( bIsAppend )
 314     {
 315         pPam->GetPoint()->nNode = nNode - 1;
 316         pTmpDoc->AppendTxtNode( *pPam->GetPoint() );
 317
 318         pPam->SetMark();
 319         pPam->Move( fnMoveBackward );
 320         pPam->Exchange();
 321
 322         if( pRedlData && IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ))
 323         {
 324             RedlineMode_t eOld = pTmpDoc->GetRedlineMode();
 325             pTmpDoc->SetRedlineMode_intern((RedlineMode_t)(eOld & ~nsRedlineMode_t::REDLINE_IGNORE));
 326             pTmpDoc->AppendRedline( new SwRedline( *pRedlData, *pPam ), true);
 327             pTmpDoc->SetRedlineMode_intern( eOld );
 328         }
 329         else if( !( nsRedlineMode_t::REDLINE_IGNORE & GetRedlineMode() ) &&
 330                 !pTmpDoc->GetRedlineTbl().empty() )
 331             pTmpDoc->SplitRedline( *pPam );
 332
 333         pPam->DeleteMark();
 334     }
 335     else
 336     {
 337         pPam->GetPoint()->nNode = nNode;
 338         SwCntntNode *const pCNd =
 339             pPam->GetPoint()->nNode.GetNode().GetCntntNode();
 340         pPam->GetPoint()->nContent.Assign( pCNd, nCntnt );
 341
 342         if( nLen )
 343         {
 344             sal_Bool bMvBkwrd = MovePtBackward( *pPam );
 345
 346             if( pTxt )
 347             {
 348                 SwTxtNode *const pTxtNode = pCNd->GetTxtNode();
 349                 OSL_ENSURE( pTxtNode, "where is my textnode ?" );
 350                 OUString const ins(
 351                     pTxtNode->InsertText( *pTxt, pPam->GetMark()->nContent,
 352                     m_nInsertFlags) );
 353                 assert(ins.getLength() == pTxt->Len()); // must succeed
 354                 DELETEZ( pTxt );
 355             }
 356             else
 357             {
 358                 // re-insert content (log out pPos before!)
 359                 sal_uLong nMvNd = pPos->nNode.GetIndex();
 360                 xub_StrLen nMvCnt = pPos->nContent.GetIndex();
 361                 DELETEZ( pPos );
 362                 MoveFromUndoNds( *pTmpDoc, nMvNd, nMvCnt, *pPam->GetMark() );
 363             }
 364             nNode = pPam->GetMark()->nNode.GetIndex();
 365             nCntnt = pPam->GetMark()->nContent.GetIndex();
 366
 367             MovePtForward( *pPam, bMvBkwrd );
 368             pPam->Exchange();
 369             if( pRedlData && IDocumentRedlineAccess::IsRedlineOn( GetRedlineMode() ))
 370             {
 371                 RedlineMode_t eOld = pTmpDoc->GetRedlineMode();
 372                 pTmpDoc->SetRedlineMode_intern((RedlineMode_t)(eOld & ~nsRedlineMode_t::REDLINE_IGNORE));
 373                 pTmpDoc->AppendRedline( new SwRedline( *pRedlData,
 374                                             *pPam ), true);
 375                 pTmpDoc->SetRedlineMode_intern( eOld );
 376             }
 377             else if( !( nsRedlineMode_t::REDLINE_IGNORE & GetRedlineMode() ) &&
 378                     !pTmpDoc->GetRedlineTbl().empty() )
 379                 pTmpDoc->SplitRedline(*pPam);
 380         }
 381     }
 382
 383     pUndoTxt = GetTxtFromDoc();
 384 }
 385
 386
 387 void SwUndoInsert::RepeatImpl(::sw::RepeatContext & rContext)
 388 {
 389     if( !nLen )
 390         return;
 391
 392     SwDoc & rDoc = rContext.GetDoc();
 393     SwNodeIndex aNd( rDoc.GetNodes(), nNode );
 394     SwCntntNode* pCNd = aNd.GetNode().GetCntntNode();
 395
 396     if( !bIsAppend && 1 == nLen )       // >1 than always Text, otherwise Graphics/OLE/Text/...
 397     {
 398         SwPaM aPaM( *pCNd, nCntnt );
 399         aPaM.SetMark();
 400         aPaM.Move(fnMoveBackward);
 401         pCNd = aPaM.GetCntntNode();
 402     }
 403
 404 // What happens with the possible selected range ???
 405
 406     switch( pCNd->GetNodeType() )
 407     {
 408     case ND_TEXTNODE:
 409         if( bIsAppend )
 410         {
 411             rDoc.AppendTxtNode( *rContext.GetRepeatPaM().GetPoint() );
 412         }
 413         else
 414         {
 415             String aTxt( ((SwTxtNode*)pCNd)->GetTxt() );
 416             ::sw::GroupUndoGuard const undoGuard(rDoc.GetIDocumentUndoRedo());
 417             rDoc.InsertString( rContext.GetRepeatPaM(),
 418                 aTxt.Copy( nCntnt - nLen, nLen ) );
 419         }
 420         break;
 421     case ND_GRFNODE:
 422         {
 423             SwGrfNode* pGrfNd = (SwGrfNode*)pCNd;
 424             String sFile, sFilter;
 425             if( pGrfNd->IsGrfLink() )
 426                 pGrfNd->GetFileFilterNms( &sFile, &sFilter );
 427
 428             rDoc.Insert( rContext.GetRepeatPaM(), sFile, sFilter,
 429                                 &pGrfNd->GetGrf(),
 430                                 0/* Graphics collection*/, NULL, NULL );
 431         }
 432         break;
 433
 434     case ND_OLENODE:
 435         {
 436             // StarView does not yet provide an option to copy a StarOBJ
 437             SvStorageRef aRef = new SvStorage( aEmptyStr );
 438             SwOLEObj& rSwOLE = (SwOLEObj&)((SwOLENode*)pCNd)->GetOLEObj();
 439
 440             // temporary storage until object is inserted
 441             // TODO/MBA: seems that here a physical copy is done - not as in drawing layer! Testing!
 442             // TODO/LATER: Copying through the container would copy the replacement image as well
 443             comphelper::EmbeddedObjectContainer aCnt;
 444             ::rtl::OUString aName = aCnt.CreateUniqueObjectName();
 445             if ( aCnt.StoreEmbeddedObject( rSwOLE.GetOleRef(), aName, sal_True ) )
 446             {
 447                 uno::Reference < embed::XEmbeddedObject > aNew = aCnt.GetEmbeddedObject( aName );
 448                 rDoc.Insert( rContext.GetRepeatPaM(),
 449                     svt::EmbeddedObjectRef( aNew,
 450                         static_cast<SwOLENode*>(pCNd)->GetAspect() ),
 451                     NULL, NULL, NULL );
 452             }
 453
 454             break;
 455         }
 456     }
 457 }
 458
 459 // #111827#
 460 SwRewriter SwUndoInsert::GetRewriter() const
 461 {
 462     SwRewriter aResult;
 463     String * pStr = NULL;
 464     bool bDone = false;
 465
 466     if (pTxt)
 467         pStr = pTxt;
 468     else if (pUndoTxt)
 469         pStr = pUndoTxt;
 470
 471     if (pStr)
 472     {
 473         String aString = ShortenString(DenoteSpecialCharacters(*pStr),
 474                                        nUndoStringLength,
 475                                        String(SW_RES(STR_LDOTS)));
 476
 477         aResult.AddRule(UndoArg1, aString);
 478
 479         bDone = true;
 480     }
 481
 482     if ( ! bDone )
 483     {
 484         aResult.AddRule(UndoArg1, String("??", RTL_TEXTENCODING_ASCII_US));
 485     }
 486
 487     return aResult;
 488 }
 489
 490
 491 // SwUndoReplace /////////////////////////////////////////////////////////
 492
 493
 494 class SwUndoReplace::Impl
 495     : private SwUndoSaveCntnt
 496 {
 497     ::rtl::OUString m_sOld;
 498     ::rtl::OUString m_sIns;
 499     sal_uLong m_nSttNd, m_nEndNd, m_nOffset;
 500     xub_StrLen m_nSttCnt, m_nEndCnt, m_nSetPos, m_nSelEnd;
 501     bool m_bSplitNext : 1;
 502     bool m_bRegExp : 1;
 503     // metadata references for paragraph and following para (if m_bSplitNext)
 504     ::boost::shared_ptr< ::sfx2::MetadatableUndo > m_pMetadataUndoStart;
 505     ::boost::shared_ptr< ::sfx2::MetadatableUndo > m_pMetadataUndoEnd;
 506
 507 public:
 508     Impl(SwPaM const& rPam, ::rtl::OUString const& rIns, bool const bRegExp);
 509     virtual ~Impl()
 510     {
 511     }
 512
 513     virtual void UndoImpl( ::sw::UndoRedoContext & );
 514     virtual void RedoImpl( ::sw::UndoRedoContext & );
 515
 516     void SetEnd(SwPaM const& rPam);
 517
 518     ::rtl::OUString const& GetOld() const { return m_sOld; }
 519     ::rtl::OUString const& GetIns() const { return m_sIns; }
 520 };
 521
 522
 523 SwUndoReplace::SwUndoReplace(SwPaM const& rPam,
 524         ::rtl::OUString const& rIns, bool const bRegExp)
 525     : SwUndo( UNDO_REPLACE )
 526     , m_pImpl(new Impl(rPam, rIns, bRegExp))
 527 {
 528 }
 529
 530 SwUndoReplace::~SwUndoReplace()
 531 {
 532 }
 533
 534 void SwUndoReplace::UndoImpl(::sw::UndoRedoContext & rContext)
 535 {
 536     m_pImpl->UndoImpl(rContext);
 537 }
 538
 539 void SwUndoReplace::RedoImpl(::sw::UndoRedoContext & rContext)
 540 {
 541     m_pImpl->RedoImpl(rContext);
 542 }
 543
 544 SwRewriter
 545 MakeUndoReplaceRewriter(sal_uLong const occurrences,
 546         ::rtl::OUString const& sOld, ::rtl::OUString const& sNew)
 547 {
 548     SwRewriter aResult;
 549
 550     if (1 < occurrences)
 551     {
 552         aResult.AddRule(UndoArg1, String::CreateFromInt32(occurrences));
 553         aResult.AddRule(UndoArg2, String(SW_RES(STR_OCCURRENCES_OF)));
 554
 555         String aTmpStr;
 556         aTmpStr += String(SW_RES(STR_START_QUOTE));
 557         aTmpStr += ShortenString(sOld, nUndoStringLength,
 558                                  SW_RES(STR_LDOTS));
 559         aTmpStr += String(SW_RES(STR_END_QUOTE));
 560         aResult.AddRule(UndoArg3, aTmpStr);
 561     }
 562     else if (1 == occurrences)
 563     {
 564         {
 565             String aTmpStr;
 566
 567             aTmpStr += String(SW_RES(STR_START_QUOTE));
 568             // #i33488 #
 569             aTmpStr += ShortenString(sOld, nUndoStringLength,
 570                                      SW_RES(STR_LDOTS));
 571             aTmpStr += String(SW_RES(STR_END_QUOTE));
 572             aResult.AddRule(UndoArg1, aTmpStr);
 573         }
 574
 575         aResult.AddRule(UndoArg2, String(SW_RES(STR_YIELDS)));
 576
 577         {
 578             String aTmpStr;
 579
 580             aTmpStr += String(SW_RES(STR_START_QUOTE));
 581             // #i33488 #
 582             aTmpStr += ShortenString(sNew, nUndoStringLength,
 583                                      SW_RES(STR_LDOTS));
 584             aTmpStr += String(SW_RES(STR_END_QUOTE));
 585             aResult.AddRule(UndoArg3, aTmpStr);
 586         }
 587     }
 588
 589     return aResult;
 590 }
 591
 592 // #111827#
 593 SwRewriter SwUndoReplace::GetRewriter() const
 594 {
 595     return MakeUndoReplaceRewriter(1, m_pImpl->GetOld(), m_pImpl->GetIns());
 596 }
 597
 598 void SwUndoReplace::SetEnd(SwPaM const& rPam)
 599 {
 600     m_pImpl->SetEnd(rPam);
 601 }
 602
 603 SwUndoReplace::Impl::Impl(
 604         SwPaM const& rPam, ::rtl::OUString const& rIns, bool const bRegExp)
 605     : m_sIns( rIns )
 606     , m_nOffset( 0 )
 607     , m_bRegExp(bRegExp)
 608 {
 609
 610     const SwPosition * pStt( rPam.Start() );
 611     const SwPosition * pEnd( rPam.End() );
 612
 613     m_nSttNd = m_nEndNd = pStt->nNode.GetIndex();
 614     m_nSttCnt = pStt->nContent.GetIndex();
 615     m_nSelEnd = m_nEndCnt = pEnd->nContent.GetIndex();
 616
 617     m_bSplitNext = m_nSttNd != pEnd->nNode.GetIndex();
 618
 619     SwTxtNode* pNd = pStt->nNode.GetNode().GetTxtNode();
 620     OSL_ENSURE( pNd, "Dude, where's my TextNode?" );
 621
 622     pHistory = new SwHistory;
 623     DelCntntIndex( *rPam.GetMark(), *rPam.GetPoint() );
 624
 625     m_nSetPos = pHistory->Count();
 626
 627     sal_uLong nNewPos = pStt->nNode.GetIndex();
 628     m_nOffset = m_nSttNd - nNewPos;
 629
 630     if ( pNd->GetpSwpHints() )
 631     {
 632         pHistory->CopyAttr( pNd->GetpSwpHints(), nNewPos, 0,
 633                             pNd->GetTxt().Len(), true );
 634     }
 635
 636     if ( m_bSplitNext )
 637     {
 638         if( pNd->HasSwAttrSet() )
 639             pHistory->CopyFmtAttr( *pNd->GetpSwAttrSet(), nNewPos );
 640         pHistory->Add( pNd->GetTxtColl(), nNewPos, ND_TEXTNODE );
 641
 642         SwTxtNode* pNext = pEnd->nNode.GetNode().GetTxtNode();
 643         sal_uLong nTmp = pNext->GetIndex();
 644         pHistory->CopyAttr( pNext->GetpSwpHints(), nTmp, 0,
 645                             pNext->GetTxt().Len(), true );
 646         if( pNext->HasSwAttrSet() )
 647             pHistory->CopyFmtAttr( *pNext->GetpSwAttrSet(), nTmp );
 648         pHistory->Add( pNext->GetTxtColl(),nTmp, ND_TEXTNODE );
 649         // METADATA: store
 650         m_pMetadataUndoStart = pNd  ->CreateUndo();
 651         m_pMetadataUndoEnd   = pNext->CreateUndo();
 652     }
 653
 654     if( !pHistory->Count() )
 655         delete pHistory, pHistory = 0;
 656
 657     xub_StrLen nECnt = m_bSplitNext ? pNd->GetTxt().Len()
 658         : pEnd->nContent.GetIndex();
 659     m_sOld = pNd->GetTxt().Copy( m_nSttCnt, nECnt - m_nSttCnt );
 660 }
 661
 662 void SwUndoReplace::Impl::UndoImpl(::sw::UndoRedoContext & rContext)
 663 {
 664     SwDoc *const pDoc = & rContext.GetDoc();
 665     SwPaM & rPam(rContext.GetCursorSupplier().CreateNewShellCursor());
 666     rPam.DeleteMark();
 667
 668     SwTxtNode* pNd = pDoc->GetNodes()[ m_nSttNd - m_nOffset ]->GetTxtNode();
 669     OSL_ENSURE( pNd, "Dude, where's my TextNode?" );
 670
 671     SwAutoCorrExceptWord* pACEWord = pDoc->GetAutoCorrExceptWord();
 672     if( pACEWord )
 673     {
 674         if ((1 == m_sIns.getLength()) && (1 == m_sOld.getLength()))
 675         {
 676             SwPosition aPos( *pNd ); aPos.nContent.Assign( pNd, m_nSttCnt );
 677             pACEWord->CheckChar( aPos, m_sOld[ 0 ] );
 678         }
 679         pDoc->SetAutoCorrExceptWord( 0 );
 680     }
 681
 682     SwIndex aIdx( pNd, m_nSttCnt );
 683     // don't look at m_sIns for deletion, maybe it was not completely inserted
 684     {
 685         rPam.GetPoint()->nNode = *pNd;
 686         rPam.GetPoint()->nContent.Assign( pNd, m_nSttCnt );
 687         rPam.SetMark();
 688         rPam.GetPoint()->nNode = m_nEndNd - m_nOffset;
 689         rPam.GetPoint()->nContent.Assign( rPam.GetCntntNode(), m_nEndCnt );
 690         // move it out of the way so it is not registered at deleted node
 691         aIdx.Assign(0, 0);
 692
 693         pDoc->DeleteAndJoin( rPam );
 694         rPam.DeleteMark();
 695         pNd = rPam.GetNode()->GetTxtNode();
 696         OSL_ENSURE( pNd, "Dude, where's my TextNode?" );
 697         aIdx.Assign( pNd, m_nSttCnt );
 698     }
 699
 700     if( m_bSplitNext )
 701     {
 702         SwPosition aPos( *pNd, aIdx );
 703         pDoc->SplitNode( aPos, false );
 704         pNd->RestoreMetadata(m_pMetadataUndoEnd);
 705         pNd = pDoc->GetNodes()[ m_nSttNd - m_nOffset ]->GetTxtNode();
 706         aIdx.Assign( pNd, m_nSttCnt );
 707         // METADATA: restore
 708         pNd->RestoreMetadata(m_pMetadataUndoStart);
 709     }
 710
 711     if (!m_sOld.isEmpty())
 712     {
 713         OUString const ins( pNd->InsertText( m_sOld, aIdx ) );
 714         assert(ins.getLength() == m_sOld.getLength()); // must succeed
 715     }
 716
 717     if( pHistory )
 718     {
 719         if( pNd->GetpSwpHints() )
 720             pNd->ClearSwpHintsArr( true );
 721
 722         pHistory->TmpRollback( pDoc, m_nSetPos, false );
 723         if ( m_nSetPos ) // there were footnotes/FlyFrames
 724         {
 725             // are there others than these?
 726             if( m_nSetPos < pHistory->Count() )
 727             {
 728                 // than save those attributes as well
 729                 SwHistory aHstr;
 730                 aHstr.Move( 0, pHistory, m_nSetPos );
 731                 pHistory->Rollback( pDoc );
 732                 pHistory->Move( 0, &aHstr );
 733             }
 734             else
 735             {
 736                 pHistory->Rollback( pDoc );
 737                 DELETEZ( pHistory );
 738             }
 739         }
 740     }
 741
 742     rPam.GetPoint()->nNode = m_nSttNd;
 743     rPam.GetPoint()->nContent = aIdx;
 744 }
 745
 746 void SwUndoReplace::Impl::RedoImpl(::sw::UndoRedoContext & rContext)
 747 {
 748     SwDoc & rDoc = rContext.GetDoc();
 749     SwPaM & rPam(rContext.GetCursorSupplier().CreateNewShellCursor());
 750     rPam.DeleteMark();
 751     rPam.GetPoint()->nNode = m_nSttNd;
 752
 753     SwTxtNode* pNd = rPam.GetPoint()->nNode.GetNode().GetTxtNode();
 754     OSL_ENSURE( pNd, "Dude, where's my TextNode?" );
 755     rPam.GetPoint()->nContent.Assign( pNd, m_nSttCnt );
 756     rPam.SetMark();
 757     if( m_bSplitNext )
 758     {
 759         rPam.GetPoint()->nNode = m_nSttNd + 1;
 760         pNd = rPam.GetPoint()->nNode.GetNode().GetTxtNode();
 761     }
 762     rPam.GetPoint()->nContent.Assign( pNd, m_nSelEnd );
 763
 764     if( pHistory )
 765     {
 766         SwHistory* pSave = pHistory;
 767         SwHistory aHst;
 768         pHistory = &aHst;
 769         DelCntntIndex( *rPam.GetMark(), *rPam.GetPoint() );
 770         m_nSetPos = pHistory->Count();
 771
 772         pHistory = pSave;
 773         pHistory->Move( 0, &aHst );
 774     }
 775     else
 776     {
 777         pHistory = new SwHistory;
 778         DelCntntIndex( *rPam.GetMark(), *rPam.GetPoint() );
 779         m_nSetPos = pHistory->Count();
 780         if( !m_nSetPos )
 781             delete pHistory, pHistory = 0;
 782     }
 783
 784     rDoc.ReplaceRange( rPam, m_sIns, m_bRegExp );
 785     rPam.DeleteMark();
 786 }
 787
 788 void SwUndoReplace::Impl::SetEnd(SwPaM const& rPam)
 789 {
 790     const SwPosition* pEnd = rPam.End();
 791     m_nEndNd = m_nOffset + pEnd->nNode.GetIndex();
 792     m_nEndCnt = pEnd->nContent.GetIndex();
 793 }
 794
 795
 796 // SwUndoReRead //////////////////////////////////////////////////////////
 797
 798
 799 SwUndoReRead::SwUndoReRead( const SwPaM& rPam, const SwGrfNode& rGrfNd )
 800     : SwUndo( UNDO_REREAD ), nPos( rPam.GetPoint()->nNode.GetIndex() )
 801 {
 802     SaveGraphicData( rGrfNd );
 803 }
 804
 805
 806 SwUndoReRead::~SwUndoReRead()
 807 {
 808     delete pGrf;
 809     delete pNm;
 810     delete pFltr;
 811 }
 812
 813
 814 void SwUndoReRead::SetAndSave(::sw::UndoRedoContext & rContext)
 815 {
 816     SwDoc & rDoc = rContext.GetDoc();
 817     SwGrfNode* pGrfNd = rDoc.GetNodes()[ nPos ]->GetGrfNode();
 818
 819     if( !pGrfNd )
 820         return ;
 821
 822     // cache the old values
 823     Graphic* pOldGrf = pGrf;
 824     String* pOldNm = pNm;
 825     String* pOldFltr = pFltr;
 826     sal_uInt16 nOldMirr = nMirr;
 827
 828     SaveGraphicData( *pGrfNd );
 829     if( pOldNm )
 830     {
 831         pGrfNd->ReRead( *pOldNm, pFltr ? *pFltr : aEmptyStr, 0, 0, sal_True );
 832         delete pOldNm;
 833         delete pOldFltr;
 834     }
 835     else
 836     {
 837         pGrfNd->ReRead( aEmptyStr, aEmptyStr, pOldGrf, 0, sal_True );
 838         delete pOldGrf;
 839     }
 840
 841     if( RES_MIRROR_GRAPH_DONT != nOldMirr )
 842         pGrfNd->SetAttr( SwMirrorGrf() );
 843
 844     rContext.SetSelections(pGrfNd->GetFlyFmt(), 0);
 845 }
 846
 847
 848 void SwUndoReRead::UndoImpl(::sw::UndoRedoContext & rContext)
 849 {
 850     SetAndSave(rContext);
 851 }
 852
 853
 854 void SwUndoReRead::RedoImpl(::sw::UndoRedoContext & rContext)
 855 {
 856     SetAndSave(rContext);
 857 }
 858
 859
 860 void SwUndoReRead::SaveGraphicData( const SwGrfNode& rGrfNd )
 861 {
 862     if( rGrfNd.IsGrfLink() )
 863     {
 864         pNm = new String;
 865         pFltr = new String;
 866         rGrfNd.GetFileFilterNms( pNm, pFltr );
 867         pGrf = 0;
 868     }
 869     else
 870     {
 871         ((SwGrfNode&)rGrfNd).SwapIn( sal_True );
 872         pGrf = new Graphic( rGrfNd.GetGrf() );
 873         pNm = pFltr = 0;
 874     }
 875     nMirr = rGrfNd.GetSwAttrSet().GetMirrorGrf().GetValue();
 876 }
 877
 878
 879 SwUndoInsertLabel::SwUndoInsertLabel( const SwLabelType eTyp,
 880                                       const String &rTxt,
 881                                       const String& rSeparator,
 882                                       const String& rNumberSeparator,
 883                                       const sal_Bool bBef,
 884                                       const sal_uInt16 nInitId,
 885                                       const String& rCharacterStyle,
 886                                       const sal_Bool bCpyBorder )
 887     : SwUndo( UNDO_INSERTLABEL ),
 888       sText( rTxt ),
 889       sSeparator( rSeparator ),
 890       sNumberSeparator( rNumberSeparator ),//#i61007# order of captions
 891       sCharacterStyle( rCharacterStyle ),
 892       nFldId( nInitId ),
 893       eType( eTyp ),
 894       nLayerId( 0 ),
 895       bBefore( bBef ),
 896       bCpyBrd( bCpyBorder )
 897 {
 898     bUndoKeep = sal_False;
 899     OBJECT.pUndoFly = 0;
 900     OBJECT.pUndoAttr = 0;
 901 }
 902
 903 SwUndoInsertLabel::~SwUndoInsertLabel()
 904 {
 905     if( LTYPE_OBJECT == eType || LTYPE_DRAW == eType )
 906     {
 907         delete OBJECT.pUndoFly;
 908         delete OBJECT.pUndoAttr;
 909     }
 910     else
 911         delete NODE.pUndoInsNd;
 912 }
 913
 914 void SwUndoInsertLabel::UndoImpl(::sw::UndoRedoContext & rContext)
 915 {
 916     SwDoc & rDoc = rContext.GetDoc();
 917
 918     if( LTYPE_OBJECT == eType || LTYPE_DRAW == eType )
 919     {
 920         OSL_ENSURE( OBJECT.pUndoAttr && OBJECT.pUndoFly, "Pointer not initialized" );
 921         SwFrmFmt* pFmt;
 922         SdrObject *pSdrObj = 0;
 923         if( OBJECT.pUndoAttr &&
 924             0 != (pFmt = (SwFrmFmt*)OBJECT.pUndoAttr->GetFmt( rDoc )) &&
 925             ( LTYPE_DRAW != eType ||
 926               0 != (pSdrObj = pFmt->FindSdrObject()) ) )
 927         {
 928             OBJECT.pUndoAttr->UndoImpl(rContext);
 929             OBJECT.pUndoFly->UndoImpl(rContext);
 930             if( LTYPE_DRAW == eType )
 931             {
 932                 pSdrObj->SetLayer( nLayerId );
 933             }
 934         }
 935     }
 936     else if( NODE.nNode )
 937     {
 938         if ( eType == LTYPE_TABLE && bUndoKeep )
 939         {
 940             SwTableNode *pNd = rDoc.GetNodes()[
 941                         rDoc.GetNodes()[NODE.nNode-1]->StartOfSectionIndex()]->GetTableNode();
 942             if ( pNd )
 943                 pNd->GetTable().GetFrmFmt()->ResetFmtAttr( RES_KEEP );
 944         }
 945         SwPaM aPam( rDoc.GetNodes().GetEndOfContent() );
 946         aPam.GetPoint()->nNode = NODE.nNode;
 947         aPam.SetMark();
 948         aPam.GetPoint()->nNode = NODE.nNode + 1;
 949         NODE.pUndoInsNd = new SwUndoDelete( aPam, sal_True );
 950     }
 951 }
 952
 953
 954 void SwUndoInsertLabel::RedoImpl(::sw::UndoRedoContext & rContext)
 955 {
 956     SwDoc & rDoc = rContext.GetDoc();
 957
 958     if( LTYPE_OBJECT == eType || LTYPE_DRAW == eType )
 959     {
 960         OSL_ENSURE( OBJECT.pUndoAttr && OBJECT.pUndoFly, "Pointer not initialized" );
 961         SwFrmFmt* pFmt;
 962         SdrObject *pSdrObj = 0;
 963         if( OBJECT.pUndoAttr &&
 964             0 != (pFmt = (SwFrmFmt*)OBJECT.pUndoAttr->GetFmt( rDoc )) &&
 965             ( LTYPE_DRAW != eType ||
 966               0 != (pSdrObj = pFmt->FindSdrObject()) ) )
 967         {
 968             OBJECT.pUndoFly->RedoImpl(rContext);
 969             OBJECT.pUndoAttr->RedoImpl(rContext);
 970             if( LTYPE_DRAW == eType )
 971             {
 972                 pSdrObj->SetLayer( nLayerId );
 973                 if( pSdrObj->GetLayer() == rDoc.GetHellId() )
 974                     pSdrObj->SetLayer( rDoc.GetHeavenId() );
 975                 // OD 02.07.2003 #108784#
 976                 else if( pSdrObj->GetLayer() == rDoc.GetInvisibleHellId() )
 977                     pSdrObj->SetLayer( rDoc.GetInvisibleHeavenId() );
 978             }
 979         }
 980     }
 981     else if( NODE.pUndoInsNd )
 982     {
 983         if ( eType == LTYPE_TABLE && bUndoKeep )
 984         {
 985             SwTableNode *pNd = rDoc.GetNodes()[
 986                         rDoc.GetNodes()[NODE.nNode-1]->StartOfSectionIndex()]->GetTableNode();
 987             if ( pNd )
 988                 pNd->GetTable().GetFrmFmt()->SetFmtAttr( SvxFmtKeepItem(sal_True, RES_KEEP) );
 989         }
 990         NODE.pUndoInsNd->UndoImpl(rContext);
 991         delete NODE.pUndoInsNd, NODE.pUndoInsNd = 0;
 992     }
 993 }
 994
 995 void SwUndoInsertLabel::RepeatImpl(::sw::RepeatContext & rContext)
 996 {
 997     SwDoc & rDoc = rContext.GetDoc();
 998     const SwPosition& rPos = *rContext.GetRepeatPaM().GetPoint();
 999
1000     sal_uLong nIdx = 0;
1001
1002     SwCntntNode* pCNd = rPos.nNode.GetNode().GetCntntNode();
1003     if( pCNd )
1004         switch( eType )
1005         {
1006         case LTYPE_TABLE:
1007             {
1008                 const SwTableNode* pTNd = pCNd->FindTableNode();
1009                 if( pTNd )
1010                     nIdx = pTNd->GetIndex();
1011             }
1012             break;
1013
1014         case LTYPE_FLY:
1015         case LTYPE_OBJECT:
1016             {
1017                 SwFlyFrm* pFly;
1018                 SwCntntFrm *pCnt = pCNd->getLayoutFrm( rDoc.GetCurrentLayout() );
1019                 if( pCnt && 0 != ( pFly = pCnt->FindFlyFrm() ) )
1020                     nIdx = pFly->GetFmt()->GetCntnt().GetCntntIdx()->GetIndex();
1021             }
1022             break;
1023         case LTYPE_DRAW:
1024             break;
1025         }
1026
1027     if( nIdx )
1028     {
1029         rDoc.InsertLabel( eType, sText, sSeparator, sNumberSeparator, bBefore,
1030             nFldId, nIdx, sCharacterStyle, bCpyBrd );
1031     }
1032 }
1033
1034 // #111827#
1035 SwRewriter SwUndoInsertLabel::GetRewriter() const
1036 {
1037     SwRewriter aRewriter;
1038
1039     String aTmpStr;
1040
1041     aTmpStr += String(SW_RES(STR_START_QUOTE));
1042     aTmpStr += ShortenString(sText, nUndoStringLength,
1043                              String(SW_RES(STR_LDOTS)));
1044     aTmpStr += String(SW_RES(STR_END_QUOTE));
1045
1046     aRewriter.AddRule(UndoArg1, aTmpStr);
1047
1048     return aRewriter;
1049 }
1050
1051 void SwUndoInsertLabel::SetFlys( SwFrmFmt& rOldFly, SfxItemSet& rChgSet,
1052                                 SwFrmFmt& rNewFly )
1053 {
1054     if( LTYPE_OBJECT == eType || LTYPE_DRAW == eType )
1055     {
1056         SwUndoFmtAttrHelper aTmp( rOldFly, false );
1057         rOldFly.SetFmtAttr( rChgSet );
1058         if ( aTmp.GetUndo() )
1059         {
1060             OBJECT.pUndoAttr = aTmp.ReleaseUndo();
1061         }
1062         OBJECT.pUndoFly = new SwUndoInsLayFmt( &rNewFly,0,0 );
1063     }
1064 }
1065
1066 void SwUndoInsertLabel::SetDrawObj( sal_uInt8 nLId )
1067 {
1068     if( LTYPE_DRAW == eType )
1069     {
1070         nLayerId = nLId;
1071     }
1072 }
1073
1074 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */