sw/source/core/undo/unovwr.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 <UndoOverwrite.hxx>
  21 #include <unotools/charclass.hxx>
  22 #include <unotools/transliterationwrapper.hxx>
  23 #include <comphelper/processfactory.hxx>
  24 #include <doc.hxx>
  25 #include <IDocumentUndoRedo.hxx>
  26 #include <IDocumentRedlineAccess.hxx>
  27 #include <IShellCursorSupplier.hxx>
  28 #include <swcrsr.hxx>
  29 #include <swundo.hxx>
  30 #include <pam.hxx>
  31 #include <ndtxt.hxx>
  32 #include <UndoCore.hxx>
  33 #include <rolbck.hxx>
  34 #include <acorrect.hxx>
  35 #include <docary.hxx>
  36 #include <strings.hrc>
  37 #include <utility>
  38
  39 using namespace ::com::sun::star;
  40 using namespace ::com::sun::star::i18n;
  41 using namespace ::com::sun::star::uno;
  42
  43 SwUndoOverwrite::SwUndoOverwrite( SwDoc& rDoc, SwPosition& rPos,
  44                                     sal_Unicode cIns )
  45     : SwUndo(SwUndoId::OVERWRITE, &rDoc),
  46       m_bGroup( false )
  47 {
  48     SwTextNode *const pTextNd = rPos.GetNode().GetTextNode();
  49     assert(pTextNd);
  50     sal_Int32 const nTextNdLen = pTextNd->GetText().getLength();
  51
  52     m_nStartNode = rPos.GetNodeIndex();
  53     m_nStartContent = rPos.GetContentIndex();
  54
  55     if( !rDoc.getIDocumentRedlineAccess().IsIgnoreRedline() && !rDoc.getIDocumentRedlineAccess().GetRedlineTable().empty() )
  56     {
  57         SwPaM aPam( rPos.GetNode(), rPos.GetContentIndex(),
  58                     rPos.GetNode(), rPos.GetContentIndex()+1 );
  59         m_pRedlSaveData.reset( new SwRedlineSaveDatas );
  60         if( !FillSaveData( aPam, *m_pRedlSaveData, false ))
  61         {
  62             m_pRedlSaveData.reset();
  63         }
  64         if (m_nStartContent < nTextNdLen)
  65         {
  66             rDoc.getIDocumentRedlineAccess().DeleteRedline(aPam, false, RedlineType::Any);
  67         }
  68     }
  69
  70     m_bInsChar = true;
  71     if( m_nStartContent < nTextNdLen )     // no pure insert?
  72     {
  73         m_aDelStr += OUStringChar( pTextNd->GetText()[m_nStartContent] );
  74         if( !m_pHistory )
  75             m_pHistory.reset( new SwHistory );
  76         SwRegHistory aRHst( *pTextNd, m_pHistory.get() );
  77         m_pHistory->CopyAttr( pTextNd->GetpSwpHints(), m_nStartNode, 0,
  78                             nTextNdLen, false );
  79         rPos.AdjustContent(+1);
  80         m_bInsChar = false;
  81     }
  82
  83     bool bOldExpFlg = pTextNd->IsIgnoreDontExpand();
  84     pTextNd->SetIgnoreDontExpand( true );
  85
  86     pTextNd->InsertText( OUString(cIns), rPos, SwInsertFlags::EMPTYEXPAND );
  87     m_aInsStr += OUStringChar( cIns );
  88
  89     if( !m_bInsChar )
  90     {
  91         const SwContentIndex aTmpIndex( rPos.GetContentNode(), rPos.GetContentIndex() - 2 );
  92         pTextNd->EraseText( aTmpIndex, 1 );
  93     }
  94     pTextNd->SetIgnoreDontExpand( bOldExpFlg );
  95
  96     m_bCacheComment = false;
  97 }
  98
  99 SwUndoOverwrite::~SwUndoOverwrite()
 100 {
 101 }
 102
 103 bool SwUndoOverwrite::CanGrouping( SwDoc& rDoc, SwPosition& rPos,
 104                                     sal_Unicode cIns )
 105 {
 106 // What is with only inserted characters?
 107
 108     // Only deletion of single chars can be combined.
 109     if( rPos.GetNodeIndex() != m_nStartNode || m_aInsStr.isEmpty()  ||
 110         ( !m_bGroup && m_aInsStr.getLength() != 1 ))
 111         return false;
 112
 113     // Is the node a TextNode at all?
 114     SwTextNode * pDelTextNd = rPos.GetNode().GetTextNode();
 115     if( !pDelTextNd ||
 116         (pDelTextNd->GetText().getLength() != rPos.GetContentIndex() &&
 117             rPos.GetContentIndex() != ( m_nStartContent + m_aInsStr.getLength() )))
 118         return false;
 119
 120     CharClass& rCC = GetAppCharClass();
 121
 122     // ask the char that should be inserted
 123     if (( CH_TXTATR_BREAKWORD == cIns || CH_TXTATR_INWORD == cIns ) ||
 124         rCC.isLetterNumeric( OUString( cIns ), 0 ) !=
 125         rCC.isLetterNumeric( m_aInsStr, m_aInsStr.getLength()-1 ) )
 126         return false;
 127
 128     if (!m_bInsChar && rPos.GetContentIndex() < pDelTextNd->GetText().getLength())
 129     {
 130         SwRedlineSaveDatas aTmpSav;
 131         SwPaM aPam( rPos.GetNode(), rPos.GetContentIndex(),
 132                     rPos.GetNode(), rPos.GetContentIndex()+1 );
 133
 134         const bool bSaved = FillSaveData( aPam, aTmpSav, false );
 135
 136         bool bOk = ( !m_pRedlSaveData && !bSaved ) ||
 137                    ( m_pRedlSaveData && bSaved &&
 138                         SwUndo::CanRedlineGroup( *m_pRedlSaveData, aTmpSav,
 139                             m_nStartContent > rPos.GetContentIndex() ));
 140         // aTmpSav.DeleteAndDestroyAll();
 141         if( !bOk )
 142             return false;
 143
 144         rDoc.getIDocumentRedlineAccess().DeleteRedline( aPam, false, RedlineType::Any );
 145     }
 146
 147     // both 'overwrites' can be combined so 'move' the corresponding character
 148     if( !m_bInsChar )
 149     {
 150         if (rPos.GetContentIndex() < pDelTextNd->GetText().getLength())
 151         {
 152             m_aDelStr += OUStringChar( pDelTextNd->GetText()[rPos.GetContentIndex()] );
 153             rPos.AdjustContent(+1);
 154         }
 155         else
 156             m_bInsChar = true;
 157     }
 158
 159     bool bOldExpFlg = pDelTextNd->IsIgnoreDontExpand();
 160     pDelTextNd->SetIgnoreDontExpand( true );
 161
 162     OUString const ins( pDelTextNd->InsertText(OUString(cIns), rPos,
 163             SwInsertFlags::EMPTYEXPAND) );
 164     assert(ins.getLength() == 1); // check in SwDoc::Overwrite => cannot fail
 165     (void) ins;
 166     m_aInsStr += OUStringChar( cIns );
 167
 168     if( !m_bInsChar )
 169     {
 170         const SwContentIndex aTmpIndex( rPos.GetContentNode(), rPos.GetContentIndex() - 2 );
 171         pDelTextNd->EraseText( aTmpIndex, 1 );
 172     }
 173     pDelTextNd->SetIgnoreDontExpand( bOldExpFlg );
 174
 175     m_bGroup = true;
 176     return true;
 177 }
 178
 179 void SwUndoOverwrite::UndoImpl(::sw::UndoRedoContext & rContext)
 180 {
 181     SwDoc& rDoc = rContext.GetDoc();
 182     SwCursor& rCurrentPam(rContext.GetCursorSupplier().CreateNewShellCursor());
 183
 184     rCurrentPam.DeleteMark();
 185     rCurrentPam.GetPoint()->Assign( m_nStartNode );
 186     SwTextNode* pTextNd = rCurrentPam.GetPointNode().GetTextNode();
 187     assert(pTextNd);
 188     SwPosition& rPtPos = *rCurrentPam.GetPoint();
 189     rPtPos.SetContent( m_nStartContent );
 190
 191     SwAutoCorrExceptWord* pACEWord = rDoc.GetAutoCorrExceptWord();
 192     if( pACEWord )
 193     {
 194         if( 1 == m_aInsStr.getLength() && 1 == m_aDelStr.getLength() )
 195             pACEWord->CheckChar( *rCurrentPam.GetPoint(), m_aDelStr[0] );
 196         rDoc.SetAutoCorrExceptWord( nullptr );
 197     }
 198
 199     // If there was not only an overwrite but also an insert, delete the surplus
 200     if( m_aInsStr.getLength() > m_aDelStr.getLength() )
 201     {
 202         rPtPos.AdjustContent( m_aDelStr.getLength() );
 203         pTextNd->EraseText( rPtPos, m_aInsStr.getLength() - m_aDelStr.getLength() );
 204         rPtPos.SetContent( m_nStartContent );
 205     }
 206
 207     if( !m_aDelStr.isEmpty() )
 208     {
 209         bool bOldExpFlg = pTextNd->IsIgnoreDontExpand();
 210         pTextNd->SetIgnoreDontExpand( true );
 211
 212         rPtPos.AdjustContent(+1);
 213         for( sal_Int32 n = 0; n < m_aDelStr.getLength(); n++  )
 214         {
 215             // do it individually, to keep the attributes!
 216             OUString aTmpStr(m_aDelStr[n]);
 217             OUString const ins( pTextNd->InsertText(aTmpStr, rPtPos) );
 218             assert(ins.getLength() == 1); // cannot fail
 219             (void) ins;
 220             rPtPos.AdjustContent(-2);
 221             pTextNd->EraseText( rPtPos, 1 );
 222             rPtPos.AdjustContent(+2);
 223         }
 224         pTextNd->SetIgnoreDontExpand( bOldExpFlg );
 225         rPtPos.AdjustContent(-1);
 226     }
 227
 228     if( m_pHistory )
 229     {
 230         if( pTextNd->GetpSwpHints() )
 231             pTextNd->ClearSwpHintsArr( false );
 232         m_pHistory->TmpRollback( &rDoc, 0, false );
 233     }
 234
 235     if( rCurrentPam.GetMark()->GetContentIndex() != m_nStartContent )
 236     {
 237         rCurrentPam.SetMark();
 238         rCurrentPam.GetMark()->SetContent( m_nStartContent );
 239     }
 240
 241     if( m_pRedlSaveData )
 242         SetSaveData( rDoc, *m_pRedlSaveData );
 243 }
 244
 245 void SwUndoOverwrite::RepeatImpl(::sw::RepeatContext & rContext)
 246 {
 247     SwPaM& rCurrentPam = rContext.GetRepeatPaM();
 248     if( m_aInsStr.isEmpty() || rCurrentPam.HasMark() )
 249         return;
 250
 251     SwDoc & rDoc = rContext.GetDoc();
 252
 253     {
 254         ::sw::GroupUndoGuard const undoGuard(rDoc.GetIDocumentUndoRedo());
 255         rDoc.getIDocumentContentOperations().Overwrite(rCurrentPam, OUString(m_aInsStr[0]));
 256     }
 257     for( sal_Int32 n = 1; n < m_aInsStr.getLength(); ++n )
 258         rDoc.getIDocumentContentOperations().Overwrite(rCurrentPam, OUString(m_aInsStr[n]));
 259 }
 260
 261 void SwUndoOverwrite::RedoImpl(::sw::UndoRedoContext & rContext)
 262 {
 263     SwDoc& rDoc = rContext.GetDoc();
 264     SwCursor& rCurrentPam(rContext.GetCursorSupplier().CreateNewShellCursor());
 265
 266     rCurrentPam.DeleteMark();
 267     rCurrentPam.GetPoint()->Assign(m_nStartNode);
 268     SwTextNode* pTextNd = rCurrentPam.GetPointNode().GetTextNode();
 269     assert(pTextNd);
 270     SwPosition& rPtPos = *rCurrentPam.GetPoint();
 271
 272     if( m_pRedlSaveData )
 273     {
 274         rPtPos.SetContent( m_nStartContent );
 275         rCurrentPam.SetMark();
 276         rCurrentPam.GetMark()->AdjustContent( m_aDelStr.getLength() );
 277         rDoc.getIDocumentRedlineAccess().DeleteRedline( rCurrentPam, false, RedlineType::Any );
 278         rCurrentPam.DeleteMark();
 279     }
 280     rPtPos.SetContent( !m_aDelStr.isEmpty() ? m_nStartContent+1 : m_nStartContent );
 281
 282     bool bOldExpFlg = pTextNd->IsIgnoreDontExpand();
 283     pTextNd->SetIgnoreDontExpand( true );
 284
 285     for( sal_Int32 n = 0; n < m_aInsStr.getLength(); n++  )
 286     {
 287         // do it individually, to keep the attributes!
 288         OUString const ins(
 289                 pTextNd->InsertText( OUString(m_aInsStr[n]), rPtPos,
 290                 SwInsertFlags::EMPTYEXPAND) );
 291         assert(ins.getLength() == 1); // cannot fail
 292         (void) ins;
 293         if( n < m_aDelStr.getLength() )
 294         {
 295             rPtPos.AdjustContent(-2);
 296             pTextNd->EraseText( rPtPos, 1 );
 297             rPtPos.AdjustContent( n+1 < m_aDelStr.getLength() ? 2 : 1 );
 298         }
 299     }
 300     pTextNd->SetIgnoreDontExpand( bOldExpFlg );
 301
 302     // get back old start position from UndoNodes array
 303     if( m_pHistory )
 304         m_pHistory->SetTmpEnd( m_pHistory->Count() );
 305     if( rCurrentPam.GetMark()->GetContentIndex() != m_nStartContent )
 306     {
 307         rCurrentPam.SetMark();
 308         rCurrentPam.GetMark()->SetContent( m_nStartContent );
 309     }
 310 }
 311
 312 SwRewriter SwUndoOverwrite::GetRewriter() const
 313 {
 314     SwRewriter aResult;
 315
 316     OUString aString = SwResId(STR_START_QUOTE) +
 317         ShortenString(m_aInsStr, nUndoStringLength, SwResId(STR_LDOTS)) +
 318         SwResId(STR_END_QUOTE);
 319
 320     aResult.AddRule(UndoArg1, aString);
 321
 322     return aResult;
 323 }
 324
 325 struct UndoTransliterate_Data
 326 {
 327     OUString        sText;
 328     std::unique_ptr<SwHistory> pHistory;
 329     std::optional<Sequence< sal_Int32 >> oOffsets;
 330     SwNodeOffset   nNdIdx;
 331     sal_Int32      nStart, nLen;
 332
 333     UndoTransliterate_Data( SwNodeOffset nNd, sal_Int32 nStt, sal_Int32 nStrLen, OUString aText )
 334         : sText(std::move( aText )),
 335         nNdIdx( nNd ), nStart( nStt ), nLen( nStrLen )
 336     {}
 337
 338     void SetChangeAtNode( SwDoc& rDoc );
 339 };
 340
 341 SwUndoTransliterate::SwUndoTransliterate(
 342     const SwPaM& rPam,
 343     const utl::TransliterationWrapper& rTrans )
 344     : SwUndo( SwUndoId::TRANSLITERATE, &rPam.GetDoc() ), SwUndRng( rPam ), m_nType( rTrans.getType() )
 345 {
 346 }
 347
 348 SwUndoTransliterate::~SwUndoTransliterate()
 349 {
 350 }
 351
 352 void SwUndoTransliterate::UndoImpl(::sw::UndoRedoContext & rContext)
 353 {
 354     SwDoc & rDoc = rContext.GetDoc();
 355
 356     // since the changes were added to the vector from the end of the string/node towards
 357     // the start, we need to revert them from the start towards the end now to keep the
 358     // offset information of the undo data in sync with the changing text.
 359     // Thus we need to iterate from the end of the vector to the start
 360     for (sal_Int32 i = m_aChanges.size() - 1; i >= 0;  --i)
 361         m_aChanges[i]->SetChangeAtNode( rDoc );
 362
 363     AddUndoRedoPaM(rContext, true);
 364 }
 365
 366 void SwUndoTransliterate::RedoImpl(::sw::UndoRedoContext & rContext)
 367 {
 368     SwPaM & rPam( AddUndoRedoPaM(rContext) );
 369     DoTransliterate(rContext.GetDoc(), rPam);
 370 }
 371
 372 void SwUndoTransliterate::RepeatImpl(::sw::RepeatContext & rContext)
 373 {
 374     DoTransliterate(rContext.GetDoc(), rContext.GetRepeatPaM());
 375 }
 376
 377 void SwUndoTransliterate::DoTransliterate(SwDoc & rDoc, SwPaM const & rPam)
 378 {
 379     utl::TransliterationWrapper aTrans( ::comphelper::getProcessComponentContext(), m_nType );
 380     rDoc.getIDocumentContentOperations().TransliterateText( rPam, aTrans );
 381 }
 382
 383 void SwUndoTransliterate::AddChanges( SwTextNode& rTNd,
 384                     sal_Int32 nStart, sal_Int32 nLen,
 385                     uno::Sequence <sal_Int32> const & rOffsets )
 386 {
 387     tools::Long nOffsLen = rOffsets.getLength();
 388     UndoTransliterate_Data* pNew = new UndoTransliterate_Data(
 389                         rTNd.GetIndex(), nStart, static_cast<sal_Int32>(nOffsLen),
 390                         rTNd.GetText().copy(nStart, nLen));
 391
 392     m_aChanges.push_back( std::unique_ptr<UndoTransliterate_Data>(pNew) );
 393
 394     const sal_Int32* pOffsets = rOffsets.getConstArray();
 395     // where did we need less memory ?
 396     const sal_Int32* p = pOffsets;
 397     for( tools::Long n = 0; n < nOffsLen; ++n, ++p )
 398     if( *p != ( nStart + n ))
 399     {
 400         // create the Offset array
 401         pNew->oOffsets.emplace( nLen );
 402         sal_Int32* pIdx = pNew->oOffsets->getArray();
 403         p = pOffsets;
 404         tools::Long nMyOff, nNewVal = nStart;
 405         for( n = 0, nMyOff = nStart; n < nOffsLen; ++p, ++n, ++nMyOff )
 406         {
 407             if( *p < nMyOff )
 408             {
 409                 // something is deleted
 410                 nMyOff = *p;
 411                 *(pIdx-1) = nNewVal++;
 412             }
 413             else if( *p > nMyOff )
 414             {
 415                 for( ; *p > nMyOff; ++nMyOff )
 416                     *pIdx++ = nNewVal;
 417                 --nMyOff;
 418                 --n;
 419                 --p;
 420             }
 421             else
 422                 *pIdx++ = nNewVal++;
 423         }
 424
 425         // and then we need to save the attributes/bookmarks
 426         // but this data must moved every time to the last in the chain!
 427         for (size_t i = 0; i + 1 < m_aChanges.size(); ++i)    // check all changes but not the current one
 428         {
 429             UndoTransliterate_Data* pD = m_aChanges[i].get();
 430             if( pD->nNdIdx == pNew->nNdIdx && pD->pHistory )
 431             {
 432                 // same node and have a history?
 433                 pNew->pHistory = std::move(pD->pHistory);
 434                 break;          // more can't exist
 435             }
 436         }
 437
 438         if( !pNew->pHistory )
 439         {
 440             pNew->pHistory.reset( new SwHistory );
 441             SwRegHistory aRHst( rTNd, pNew->pHistory.get() );
 442             pNew->pHistory->CopyAttr( rTNd.GetpSwpHints(),
 443                     pNew->nNdIdx, 0, rTNd.GetText().getLength(), false );
 444         }
 445         break;
 446     }
 447 }
 448
 449 void UndoTransliterate_Data::SetChangeAtNode( SwDoc& rDoc )
 450 {
 451     SwTextNode* pTNd = rDoc.GetNodes()[ nNdIdx ]->GetTextNode();
 452     if( !pTNd )
 453         return;
 454
 455     Sequence <sal_Int32> aOffsets( oOffsets ? oOffsets->getLength() : nLen );
 456     if( oOffsets )
 457         aOffsets = *oOffsets;
 458     else
 459     {
 460         sal_Int32* p = aOffsets.getArray();
 461         for( sal_Int32 n = 0; n < nLen; ++n, ++p )
 462             *p = n + nStart;
 463     }
 464     pTNd->ReplaceTextOnly( nStart, nLen, sText, aOffsets );
 465
 466     if( pHistory )
 467     {
 468         if( pTNd->GetpSwpHints() )
 469             pTNd->ClearSwpHintsArr( false );
 470         pHistory->TmpRollback( &rDoc, 0, false );
 471         pHistory->SetTmpEnd( pHistory->Count() );
 472     }
 473 }
 474
 475 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */