sc/source/ui/undo/undoblk3.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 <sal/config.h>
  21
  22 #include <memory>
  23
  24 #include <scitems.hxx>
  25 #include <editeng/boxitem.hxx>
  26 #include <editeng/justifyitem.hxx>
  27 #include <svl/srchitem.hxx>
  28 #include <sfx2/linkmgr.hxx>
  29 #include <utility>
  30 #include <vcl/virdev.hxx>
  31 #include <sfx2/app.hxx>
  32 #include <svx/svdundo.hxx>
  33 #include <osl/diagnose.h>
  34
  35 #include <undoblk.hxx>
  36 #include <globstr.hrc>
  37 #include <scresid.hxx>
  38 #include <global.hxx>
  39 #include <arealink.hxx>
  40 #include <patattr.hxx>
  41 #include <target.hxx>
  42 #include <document.hxx>
  43 #include <docpool.hxx>
  44 #include <docsh.hxx>
  45 #include <tabvwsh.hxx>
  46 #include <undoolk.hxx>
  47 #include <undoutil.hxx>
  48 #include <chgtrack.hxx>
  49 #include <paramisc.hxx>
  50 #include <postit.hxx>
  51 #include <progress.hxx>
  52 #include <editutil.hxx>
  53 #include <editdataarray.hxx>
  54 #include <rowheightcontext.hxx>
  55
  56 // TODO:
  57 /*A*/   // SetOptimalHeight on Document, when no View
  58
  59 ScUndoDeleteContents::ScUndoDeleteContents(
  60                 ScDocShell* pNewDocShell,
  61                 const ScMarkData& rMark, const ScRange& rRange,
  62                 ScDocumentUniquePtr&& pNewUndoDoc, bool bNewMulti,
  63                 InsertDeleteFlags nNewFlags, bool bObjects )
  64     :   ScSimpleUndo( pNewDocShell ),
  65         aRange      ( rRange ),
  66         aMarkData   ( rMark ),
  67         pUndoDoc    ( std::move(pNewUndoDoc) ),
  68         nFlags      ( nNewFlags ),
  69         bMulti      ( bNewMulti )   // unnecessary
  70 {
  71     if (bObjects)
  72         pDrawUndo = GetSdrUndoAction( &pDocShell->GetDocument() );
  73
  74     if ( !(aMarkData.IsMarked() || aMarkData.IsMultiMarked()) )     // if no cell is selected:
  75         aMarkData.SetMarkArea( aRange );                            // select cell under cursor
  76
  77     SetChangeTrack();
  78 }
  79
  80 ScUndoDeleteContents::~ScUndoDeleteContents()
  81 {
  82     pUndoDoc.reset();
  83     pDrawUndo.reset();
  84 }
  85
  86 OUString ScUndoDeleteContents::GetComment() const
  87 {
  88     return ScResId( STR_UNDO_DELETECONTENTS );    // "Delete"
  89 }
  90
  91 void ScUndoDeleteContents::SetDataSpans( const std::shared_ptr<DataSpansType>& pSpans )
  92 {
  93     mpDataSpans = pSpans;
  94 }
  95
  96 void ScUndoDeleteContents::SetChangeTrack()
  97 {
  98     ScChangeTrack* pChangeTrack = pDocShell->GetDocument().GetChangeTrack();
  99     if ( pChangeTrack && (nFlags & InsertDeleteFlags::CONTENTS) )
 100         pChangeTrack->AppendContentRange( aRange, pUndoDoc.get(),
 101             nStartChangeAction, nEndChangeAction );
 102     else
 103         nStartChangeAction = nEndChangeAction = 0;
 104 }
 105
 106 void ScUndoDeleteContents::DoChange( const bool bUndo )
 107 {
 108     ScDocument& rDoc = pDocShell->GetDocument();
 109
 110     SetViewMarkData( aMarkData );
 111
 112     sal_uInt16 nExtFlags = 0;
 113
 114     if (bUndo)  // only Undo
 115     {
 116         InsertDeleteFlags nUndoFlags = InsertDeleteFlags::NONE; // copy either all or none of the content
 117         if (nFlags & InsertDeleteFlags::CONTENTS)        // (Only the correct ones have been copied into UndoDoc)
 118             nUndoFlags |= InsertDeleteFlags::CONTENTS;
 119         if (nFlags & InsertDeleteFlags::ATTRIB)
 120             nUndoFlags |= InsertDeleteFlags::ATTRIB;
 121         if (nFlags & InsertDeleteFlags::EDITATTR)          // Edit-Engine attribute
 122             nUndoFlags |= InsertDeleteFlags::STRING;       // -> Cells will be changed
 123         if (nFlags & InsertDeleteFlags::SPARKLINES)
 124             nUndoFlags |= InsertDeleteFlags::SPARKLINES;
 125         // do not create clones of note captions, they will be restored via drawing undo
 126         nUndoFlags |= InsertDeleteFlags::NOCAPTIONS;
 127
 128         ScRange aCopyRange = aRange;
 129         SCTAB nTabCount = rDoc.GetTableCount();
 130         aCopyRange.aStart.SetTab(0);
 131         aCopyRange.aEnd.SetTab(nTabCount-1);
 132
 133         pUndoDoc->CopyToDocument(aCopyRange, nUndoFlags, bMulti, rDoc, &aMarkData);
 134
 135         DoSdrUndoAction( pDrawUndo.get(), &rDoc );
 136
 137         ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
 138         if ( pChangeTrack )
 139             pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
 140
 141         pDocShell->UpdatePaintExt( nExtFlags, aRange );             // content after the change
 142     }
 143     else        // only Redo
 144     {
 145         pDocShell->UpdatePaintExt( nExtFlags, aRange );             // content before the change
 146
 147         aMarkData.MarkToMulti();
 148         RedoSdrUndoAction( pDrawUndo.get() );
 149         // do not delete objects and note captions, they have been removed via drawing undo
 150         InsertDeleteFlags nRedoFlags = (nFlags & ~InsertDeleteFlags::OBJECTS) | InsertDeleteFlags::NOCAPTIONS;
 151         rDoc.DeleteSelection( nRedoFlags, aMarkData );
 152         aMarkData.MarkToSimple();
 153
 154         SetChangeTrack();
 155     }
 156
 157     if (nFlags & InsertDeleteFlags::CONTENTS)
 158     {
 159         // Broadcast only when the content changes. fdo#74687
 160         if (mpDataSpans)
 161             BroadcastChanges(*mpDataSpans);
 162         else
 163             BroadcastChanges(aRange);
 164     }
 165
 166     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 167     if ( !( pViewShell && pViewShell->AdjustRowHeight(
 168                                 aRange.aStart.Row(), aRange.aEnd.Row(), true ) ) )
 169 /*A*/   pDocShell->PostPaint( aRange, PaintPartFlags::Grid | PaintPartFlags::Extras, nExtFlags );
 170
 171     if (pViewShell)
 172         pViewShell->CellContentChanged();
 173
 174     ShowTable( aRange );
 175 }
 176
 177 void ScUndoDeleteContents::Undo()
 178 {
 179     BeginUndo();
 180     DoChange( true );
 181     EndUndo();
 182
 183     HelperNotifyChanges::NotifyIfChangesListeners(*pDocShell, aRange, u"undo"_ustr);
 184 }
 185
 186 void ScUndoDeleteContents::Redo()
 187 {
 188     BeginRedo();
 189     DoChange( false );
 190     EndRedo();
 191
 192     HelperNotifyChanges::NotifyIfChangesListeners(*pDocShell, aRange, u"redo"_ustr);
 193 }
 194
 195 void ScUndoDeleteContents::Repeat(SfxRepeatTarget& rTarget)
 196 {
 197     if (auto pViewTarget = dynamic_cast<ScTabViewTarget*>( &rTarget))
 198         pViewTarget->GetViewShell()->DeleteContents( nFlags );
 199 }
 200
 201 bool ScUndoDeleteContents::CanRepeat(SfxRepeatTarget& rTarget) const
 202 {
 203     return dynamic_cast<const ScTabViewTarget*>( &rTarget) !=  nullptr;
 204 }
 205
 206 ScUndoFillTable::ScUndoFillTable( ScDocShell* pNewDocShell,
 207                 const ScMarkData& rMark,
 208                 SCCOL nStartX, SCROW nStartY, SCTAB nStartZ,
 209                 SCCOL nEndX, SCROW nEndY, SCTAB nEndZ,
 210                 ScDocumentUniquePtr pNewUndoDoc, bool bNewMulti, SCTAB nSrc,
 211                 InsertDeleteFlags nFlg, ScPasteFunc nFunc, bool bSkip, bool bLink )
 212     :   ScSimpleUndo( pNewDocShell ),
 213         aRange      ( nStartX, nStartY, nStartZ, nEndX, nEndY, nEndZ ),
 214         aMarkData   ( rMark ),
 215         pUndoDoc    ( std::move(pNewUndoDoc) ),
 216         nFlags      ( nFlg ),
 217         nFunction   ( nFunc ),
 218         nSrcTab     ( nSrc ),
 219         bMulti      ( bNewMulti ),
 220         bSkipEmpty  ( bSkip ),
 221         bAsLink     ( bLink )
 222 {
 223     SetChangeTrack();
 224 }
 225
 226 ScUndoFillTable::~ScUndoFillTable()
 227 {
 228 }
 229
 230 OUString ScUndoFillTable::GetComment() const
 231 {
 232     return ScResId( STR_FILL_TAB );
 233 }
 234
 235 void ScUndoFillTable::SetChangeTrack()
 236 {
 237     ScChangeTrack* pChangeTrack = pDocShell->GetDocument().GetChangeTrack();
 238     if ( pChangeTrack )
 239     {
 240         SCTAB nTabCount = pDocShell->GetDocument().GetTableCount();
 241         ScRange aWorkRange(aRange);
 242         nStartChangeAction = 0;
 243         sal_uLong nTmpAction;
 244         for (const auto& rTab : aMarkData)
 245         {
 246             if (rTab >= nTabCount)
 247                 break;
 248             if (rTab != nSrcTab)
 249             {
 250                 aWorkRange.aStart.SetTab(rTab);
 251                 aWorkRange.aEnd.SetTab(rTab);
 252                 pChangeTrack->AppendContentRange( aWorkRange, pUndoDoc.get(),
 253                     nTmpAction, nEndChangeAction );
 254                 if ( !nStartChangeAction )
 255                     nStartChangeAction = nTmpAction;
 256             }
 257         }
 258     }
 259     else
 260         nStartChangeAction = nEndChangeAction = 0;
 261 }
 262
 263 void ScUndoFillTable::DoChange( const bool bUndo )
 264 {
 265     ScDocument& rDoc = pDocShell->GetDocument();
 266
 267     SetViewMarkData( aMarkData );
 268
 269     if (bUndo)  // only Undo
 270     {
 271         SCTAB nTabCount = rDoc.GetTableCount();
 272         ScRange aWorkRange(aRange);
 273         for (const auto& rTab : aMarkData)
 274         {
 275             if (rTab >= nTabCount)
 276                 break;
 277             if (rTab != nSrcTab)
 278             {
 279                 aWorkRange.aStart.SetTab(rTab);
 280                 aWorkRange.aEnd.SetTab(rTab);
 281                 if (bMulti)
 282                     rDoc.DeleteSelectionTab( rTab, InsertDeleteFlags::ALL, aMarkData );
 283                 else
 284                     rDoc.DeleteAreaTab( aWorkRange, InsertDeleteFlags::ALL );
 285                 pUndoDoc->CopyToDocument(aWorkRange, InsertDeleteFlags::ALL, bMulti, rDoc, &aMarkData);
 286             }
 287         }
 288
 289         ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
 290         if ( pChangeTrack )
 291             pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
 292     }
 293     else        // only Redo
 294     {
 295         aMarkData.MarkToMulti();
 296         rDoc.FillTabMarked( nSrcTab, aMarkData, nFlags, nFunction, bSkipEmpty, bAsLink );
 297         aMarkData.MarkToSimple();
 298         SetChangeTrack();
 299     }
 300
 301     pDocShell->PostPaint(0,0,0,rDoc.MaxCol(),rDoc.MaxRow(),MAXTAB, PaintPartFlags::Grid|PaintPartFlags::Extras);
 302     pDocShell->PostDataChanged();
 303
 304     //  CellContentChanged comes with the selection
 305
 306     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 307     if (pViewShell)
 308     {
 309         SCTAB nTab = pViewShell->GetViewData().GetTabNo();
 310         if ( !aMarkData.GetTableSelect(nTab) )
 311             pViewShell->SetTabNo( nSrcTab );
 312
 313         pViewShell->DoneBlockMode();    // causes problems otherwise since selection is on the wrong sheet.
 314     }
 315 }
 316
 317 void ScUndoFillTable::Undo()
 318 {
 319     BeginUndo();
 320     DoChange( true );
 321     EndUndo();
 322 }
 323
 324 void ScUndoFillTable::Redo()
 325 {
 326     BeginRedo();
 327     DoChange( false );
 328     EndRedo();
 329 }
 330
 331 void ScUndoFillTable::Repeat(SfxRepeatTarget& rTarget)
 332 {
 333     if (auto pViewTarget = dynamic_cast<ScTabViewTarget*>( &rTarget))
 334         pViewTarget->GetViewShell()->FillTab( nFlags, nFunction, bSkipEmpty, bAsLink );
 335 }
 336
 337 bool ScUndoFillTable::CanRepeat(SfxRepeatTarget& rTarget) const
 338 {
 339     return dynamic_cast<const ScTabViewTarget*>( &rTarget) !=  nullptr;
 340 }
 341
 342 ScUndoSelectionAttr::ScUndoSelectionAttr( ScDocShell* pNewDocShell,
 343                 const ScMarkData& rMark,
 344                 SCCOL nStartX, SCROW nStartY, SCTAB nStartZ,
 345                 SCCOL nEndX, SCROW nEndY, SCTAB nEndZ,
 346                 ScDocumentUniquePtr pNewUndoDoc, bool bNewMulti,
 347                 const ScPatternAttr* pNewApply,
 348                 const SvxBoxItem* pNewOuter, const SvxBoxInfoItem* pNewInner,
 349                 const ScRange* pRangeCover )
 350     :   ScSimpleUndo( pNewDocShell ),
 351         aMarkData   ( rMark ),
 352         aRange      ( nStartX, nStartY, nStartZ, nEndX, nEndY, nEndZ ),
 353         mpDataArray(new ScEditDataArray),
 354         pUndoDoc    ( std::move(pNewUndoDoc) ),
 355         bMulti      ( bNewMulti ),
 356         aApplyPattern( pNewApply ),
 357         maLineOuter(*pDocShell->GetDocument().GetPool(), pNewOuter),
 358         maLineInner(*pDocShell->GetDocument().GetPool(), pNewInner)
 359 {
 360     aRangeCover = pRangeCover ? *pRangeCover : aRange;
 361 }
 362
 363 ScUndoSelectionAttr::~ScUndoSelectionAttr()
 364 {
 365     pUndoDoc.reset();
 366 }
 367
 368 OUString ScUndoSelectionAttr::GetComment() const
 369 {
 370     //"Attribute" "/Lines"
 371     return ScResId( maLineOuter.getItem() ? STR_UNDO_SELATTRLINES : STR_UNDO_SELATTR );
 372 }
 373
 374 ScEditDataArray* ScUndoSelectionAttr::GetDataArray()
 375 {
 376     return mpDataArray.get();
 377 }
 378
 379 void ScUndoSelectionAttr::DoChange( const bool bUndo )
 380 {
 381     ScDocument& rDoc = pDocShell->GetDocument();
 382
 383     SetViewMarkData( aMarkData );
 384
 385     ScRange aEffRange( aRangeCover );
 386     if ( rDoc.HasAttrib( aEffRange, HasAttrFlags::Merged ) )         // merged cells?
 387         rDoc.ExtendMerge( aEffRange );
 388
 389     sal_uInt16 nExtFlags = 0;
 390     pDocShell->UpdatePaintExt( nExtFlags, aEffRange );
 391
 392     ChangeEditData(bUndo);
 393
 394     if (bUndo)  // only for Undo
 395     {
 396         ScRange aCopyRange = aRangeCover;
 397         SCTAB nTabCount = rDoc.GetTableCount();
 398         aCopyRange.aStart.SetTab(0);
 399         aCopyRange.aEnd.SetTab(nTabCount-1);
 400         pUndoDoc->CopyToDocument(aCopyRange, InsertDeleteFlags::ATTRIB, bMulti, rDoc, &aMarkData);
 401     }
 402     else        // only for Redo
 403     {
 404         aMarkData.MarkToMulti();
 405         rDoc.ApplySelectionPattern( *aApplyPattern.getScPatternAttr(), aMarkData );
 406         aMarkData.MarkToSimple();
 407
 408         if (maLineOuter.getItem())
 409             rDoc.ApplySelectionFrame(aMarkData,
 410                 *static_cast<const SvxBoxItem*>(maLineOuter.getItem()),
 411                 static_cast<const SvxBoxInfoItem*>(maLineInner.getItem()));
 412     }
 413
 414     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 415     if ( !( pViewShell && pViewShell->AdjustBlockHeight() ) )
 416 /*A*/   pDocShell->PostPaint( aEffRange, PaintPartFlags::Grid | PaintPartFlags::Extras, nExtFlags );
 417
 418     ShowTable( aRange );
 419 }
 420
 421 void ScUndoSelectionAttr::ChangeEditData( const bool bUndo )
 422 {
 423     ScDocument& rDoc = pDocShell->GetDocument();
 424     for (const ScEditDataArray::Item* pItem = mpDataArray->First(); pItem; pItem = mpDataArray->Next())
 425     {
 426         ScAddress aPos(pItem->GetCol(), pItem->GetRow(), pItem->GetTab());
 427         if (rDoc.GetCellType(aPos) != CELLTYPE_EDIT)
 428             continue;
 429
 430         if (bUndo)
 431         {
 432             if (pItem->GetOldData())
 433                 rDoc.SetEditText(aPos, *pItem->GetOldData(), nullptr);
 434             else
 435                 rDoc.SetEmptyCell(aPos);
 436         }
 437         else
 438         {
 439             if (pItem->GetNewData())
 440                 rDoc.SetEditText(aPos, *pItem->GetNewData(), nullptr);
 441             else
 442                 rDoc.SetEmptyCell(aPos);
 443         }
 444     }
 445 }
 446
 447 void ScUndoSelectionAttr::Undo()
 448 {
 449     BeginUndo();
 450     DoChange( true );
 451     EndUndo();
 452 }
 453
 454 void ScUndoSelectionAttr::Redo()
 455 {
 456     BeginRedo();
 457     DoChange( false );
 458     EndRedo();
 459 }
 460
 461 void ScUndoSelectionAttr::Repeat(SfxRepeatTarget& rTarget)
 462 {
 463     if (auto pViewTarget = dynamic_cast<ScTabViewTarget*>( &rTarget))
 464     {
 465         ScTabViewShell& rViewShell = *pViewTarget->GetViewShell();
 466         if (maLineOuter.getItem())
 467             rViewShell.ApplyPatternLines(*aApplyPattern.getScPatternAttr(),
 468                 *static_cast<const SvxBoxItem*>(maLineOuter.getItem()),
 469                 static_cast<const SvxBoxInfoItem*>(maLineInner.getItem()));
 470         else
 471             rViewShell.ApplySelectionPattern( *aApplyPattern.getScPatternAttr() );
 472     }
 473 }
 474
 475 bool ScUndoSelectionAttr::CanRepeat(SfxRepeatTarget& rTarget) const
 476 {
 477     return dynamic_cast<const ScTabViewTarget*>( &rTarget) !=  nullptr;
 478 }
 479
 480 ScUndoAutoFill::ScUndoAutoFill( ScDocShell* pNewDocShell,
 481                 const ScRange& rRange, const ScRange& rSourceArea,
 482                 ScDocumentUniquePtr pNewUndoDoc, const ScMarkData& rMark,
 483                 FillDir eNewFillDir, FillCmd eNewFillCmd, FillDateCmd eNewFillDateCmd,
 484                 double fNewStartValue, double fNewStepValue, double fNewMaxValue )
 485     :   ScBlockUndo( pNewDocShell, rRange, SC_UNDO_AUTOHEIGHT ),
 486         aSource         ( rSourceArea ),
 487         aMarkData       ( rMark ),
 488         pUndoDoc        ( std::move(pNewUndoDoc) ),
 489         eFillDir        ( eNewFillDir ),
 490         eFillCmd        ( eNewFillCmd ),
 491         eFillDateCmd    ( eNewFillDateCmd ),
 492         fStartValue     ( fNewStartValue ),
 493         fStepValue      ( fNewStepValue ),
 494         fMaxValue       ( fNewMaxValue )
 495 {
 496     SetChangeTrack();
 497 }
 498
 499 ScUndoAutoFill::~ScUndoAutoFill()
 500 {
 501 }
 502
 503 OUString ScUndoAutoFill::GetComment() const
 504 {
 505     return ScResId( STR_UNDO_AUTOFILL ); //"Fill"
 506 }
 507
 508 void ScUndoAutoFill::SetChangeTrack()
 509 {
 510     ScChangeTrack* pChangeTrack = pDocShell->GetDocument().GetChangeTrack();
 511     if ( pChangeTrack )
 512         pChangeTrack->AppendContentRange( aBlockRange, pUndoDoc.get(),
 513             nStartChangeAction, nEndChangeAction );
 514     else
 515         nStartChangeAction = nEndChangeAction = 0;
 516 }
 517
 518 void ScUndoAutoFill::Undo()
 519 {
 520     BeginUndo();
 521
 522     ScDocument& rDoc = pDocShell->GetDocument();
 523
 524     SCTAB nTabCount = rDoc.GetTableCount();
 525     for (const auto& rTab : aMarkData)
 526     {
 527         if (rTab >= nTabCount)
 528             break;
 529         ScRange aWorkRange = aBlockRange;
 530         aWorkRange.aStart.SetTab(rTab);
 531         aWorkRange.aEnd.SetTab(rTab);
 532
 533         sal_uInt16 nExtFlags = 0;
 534         pDocShell->UpdatePaintExt( nExtFlags, aWorkRange );
 535         rDoc.DeleteAreaTab( aWorkRange, InsertDeleteFlags::AUTOFILL );
 536         pUndoDoc->CopyToDocument(aWorkRange, InsertDeleteFlags::AUTOFILL, false, rDoc);
 537
 538         // Actually we'd only need to broadcast the cells inserted during
 539         // CopyToDocument(), as DeleteAreaTab() broadcasts deleted cells. For
 540         // this we'd need to either record the span sets or let
 541         // CopyToDocument() broadcast.
 542         BroadcastChanges( aWorkRange);
 543
 544         rDoc.ExtendMerge( aWorkRange, true );
 545         pDocShell->PostPaint( aWorkRange, PaintPartFlags::Grid, nExtFlags );
 546     }
 547     pDocShell->PostDataChanged();
 548     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 549     if (pViewShell)
 550         pViewShell->CellContentChanged();
 551
 552     ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
 553     if ( pChangeTrack )
 554         pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
 555
 556     EndUndo();
 557 }
 558
 559 void ScUndoAutoFill::Redo()
 560 {
 561     BeginRedo();
 562
 563 //! Select sheet
 564
 565     SCCOLROW nCount = 0;
 566     switch (eFillDir)
 567     {
 568         case FILL_TO_BOTTOM:
 569             nCount = aBlockRange.aEnd.Row() - aSource.aEnd.Row();
 570             break;
 571         case FILL_TO_RIGHT:
 572             nCount = aBlockRange.aEnd.Col() - aSource.aEnd.Col();
 573             break;
 574         case FILL_TO_TOP:
 575             nCount = aSource.aStart.Row() - aBlockRange.aStart.Row();
 576             break;
 577         case FILL_TO_LEFT:
 578             nCount = aSource.aStart.Col() - aBlockRange.aStart.Col();
 579             break;
 580     }
 581
 582     ScDocument& rDoc = pDocShell->GetDocument();
 583     if ( fStartValue != MAXDOUBLE )
 584     {
 585         SCCOL nValX = (eFillDir == FILL_TO_LEFT) ? aSource.aEnd.Col() : aSource.aStart.Col();
 586         SCROW nValY = (eFillDir == FILL_TO_TOP ) ? aSource.aEnd.Row() : aSource.aStart.Row();
 587         SCTAB nTab = aSource.aStart.Tab();
 588         rDoc.SetValue( nValX, nValY, nTab, fStartValue );
 589     }
 590     sal_uLong nProgCount;
 591     if (eFillDir == FILL_TO_BOTTOM || eFillDir == FILL_TO_TOP)
 592         nProgCount = aSource.aEnd.Col() - aSource.aStart.Col() + 1;
 593     else
 594         nProgCount = aSource.aEnd.Row() - aSource.aStart.Row() + 1;
 595     nProgCount *= nCount;
 596     ScProgress aProgress( rDoc.GetDocumentShell(),
 597             ScResId(STR_FILL_SERIES_PROGRESS), nProgCount, true );
 598
 599     rDoc.Fill( aSource.aStart.Col(), aSource.aStart.Row(),
 600             aSource.aEnd.Col(), aSource.aEnd.Row(), &aProgress,
 601             aMarkData, nCount,
 602             eFillDir, eFillCmd, eFillDateCmd,
 603             fStepValue, fMaxValue );
 604
 605     SetChangeTrack();
 606
 607     pDocShell->PostPaint( aBlockRange, PaintPartFlags::Grid );
 608     pDocShell->PostDataChanged();
 609     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 610     if (pViewShell)
 611         pViewShell->CellContentChanged();
 612
 613     EndRedo();
 614 }
 615
 616 void ScUndoAutoFill::Repeat(SfxRepeatTarget& rTarget)
 617 {
 618     if (auto pViewTarget = dynamic_cast<ScTabViewTarget*>( &rTarget))
 619     {
 620         ScTabViewShell& rViewShell = *pViewTarget->GetViewShell();
 621         if (eFillCmd==FILL_SIMPLE)
 622             rViewShell.FillSimple( eFillDir );
 623         else
 624             rViewShell.FillSeries( eFillDir, eFillCmd, eFillDateCmd,
 625                                    fStartValue, fStepValue, fMaxValue );
 626     }
 627 }
 628
 629 bool ScUndoAutoFill::CanRepeat(SfxRepeatTarget& rTarget) const
 630 {
 631     return dynamic_cast<const ScTabViewTarget*>( &rTarget) !=  nullptr;
 632 }
 633
 634 ScUndoMerge::ScUndoMerge(ScDocShell* pNewDocShell, ScCellMergeOption aOption,
 635                          bool bMergeContents, ScDocumentUniquePtr pUndoDoc, std::unique_ptr<SdrUndoAction> pDrawUndo)
 636     : ScSimpleUndo(pNewDocShell)
 637     , maOption(std::move(aOption))
 638     , mbMergeContents(bMergeContents)
 639     , mxUndoDoc(std::move(pUndoDoc))
 640     , mpDrawUndo(std::move(pDrawUndo))
 641 {
 642 }
 643
 644 ScUndoMerge::~ScUndoMerge()
 645 {
 646     mpDrawUndo.reset();
 647 }
 648
 649 OUString ScUndoMerge::GetComment() const
 650 {
 651     return ScResId( STR_UNDO_MERGE );
 652 }
 653
 654 void ScUndoMerge::DoChange( bool bUndo ) const
 655 {
 656     using ::std::set;
 657
 658     if (maOption.maTabs.empty())
 659         // Nothing to do.
 660         return;
 661
 662     ScDocument& rDoc = pDocShell->GetDocument();
 663     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 664
 665     ScRange aCurRange = maOption.getSingleRange(ScDocShell::GetCurTab());
 666     ScUndoUtil::MarkSimpleBlock(pDocShell, aCurRange);
 667
 668     for (const SCTAB nTab : maOption.maTabs)
 669     {
 670         ScRange aRange = maOption.getSingleRange(nTab);
 671
 672         if (bUndo)
 673             // remove merge (contents are copied back below from undo document)
 674             rDoc.RemoveMerge( aRange.aStart.Col(), aRange.aStart.Row(), aRange.aStart.Tab() );
 675         else
 676         {
 677             // repeat merge, but do not remove note captions (will be done by drawing redo below)
 678             rDoc.DoMerge( aRange.aStart.Col(), aRange.aStart.Row(),
 679                           aRange.aEnd.Col(),   aRange.aEnd.Row(),
 680                           aRange.aStart.Tab(), false );
 681
 682             if (maOption.mbCenter)
 683             {
 684                 rDoc.ApplyAttr( aRange.aStart.Col(), aRange.aStart.Row(),
 685                                  aRange.aStart.Tab(),
 686                                  SvxHorJustifyItem( SvxCellHorJustify::Center, ATTR_HOR_JUSTIFY ) );
 687                 rDoc.ApplyAttr( aRange.aStart.Col(), aRange.aStart.Row(),
 688                                  aRange.aStart.Tab(),
 689                                  SvxVerJustifyItem( SvxCellVerJustify::Center, ATTR_VER_JUSTIFY ) );
 690             }
 691         }
 692
 693         // undo -> copy back deleted contents
 694         if (bUndo && mxUndoDoc)
 695         {
 696             // If there are note captions to be deleted during Undo they were
 697             // kept or moved during the merge and copied to the Undo document
 698             // without cloning the caption. Forget the target area's caption
 699             // pointer that is identical to the one in the Undo document
 700             // instead of deleting it.
 701             rDoc.DeleteAreaTab( aRange,
 702                     InsertDeleteFlags::CONTENTS | InsertDeleteFlags::NOCAPTIONS | InsertDeleteFlags::FORGETCAPTIONS );
 703             mxUndoDoc->CopyToDocument(aRange, InsertDeleteFlags::ALL|InsertDeleteFlags::NOCAPTIONS, false, rDoc);
 704         }
 705
 706         // redo -> merge contents again
 707         else if (!bUndo && mbMergeContents)
 708         {
 709             rDoc.DoMergeContents( aRange.aStart.Col(), aRange.aStart.Row(),
 710                                   aRange.aEnd.Col(), aRange.aEnd.Row(),
 711                                   aRange.aStart.Tab() );
 712         }
 713
 714         if (bUndo)
 715             DoSdrUndoAction( mpDrawUndo.get(), &rDoc );
 716         else
 717             RedoSdrUndoAction( mpDrawUndo.get() );
 718
 719         bool bDidPaint = false;
 720         if ( pViewShell )
 721         {
 722             pViewShell->SetTabNo(nTab);
 723             bDidPaint = pViewShell->AdjustRowHeight(maOption.mnStartRow, maOption.mnEndRow, true);
 724         }
 725
 726         if (!bDidPaint)
 727             ScUndoUtil::PaintMore(pDocShell, aRange);
 728
 729         rDoc.BroadcastCells(aRange, SfxHintId::ScDataChanged);
 730     }
 731
 732     ShowTable(aCurRange);
 733 }
 734
 735 void ScUndoMerge::Undo()
 736 {
 737     BeginUndo();
 738     DoChange( true );
 739     EndUndo();
 740 }
 741
 742 void ScUndoMerge::Redo()
 743 {
 744     BeginRedo();
 745     DoChange( false );
 746     EndRedo();
 747 }
 748
 749 void ScUndoMerge::Repeat(SfxRepeatTarget& rTarget)
 750 {
 751     if (auto pViewTarget = dynamic_cast<ScTabViewTarget*>( &rTarget))
 752     {
 753         ScTabViewShell& rViewShell = *pViewTarget->GetViewShell();
 754         rViewShell.MergeCells( false, false, false, 0 );
 755     }
 756 }
 757
 758 bool ScUndoMerge::CanRepeat(SfxRepeatTarget& rTarget) const
 759 {
 760     return dynamic_cast<const ScTabViewTarget*>( &rTarget) !=  nullptr;
 761 }
 762
 763 ScUndoAutoFormat::ScUndoAutoFormat( ScDocShell* pNewDocShell,
 764                         const ScRange& rRange, ScDocumentUniquePtr pNewUndoDoc,
 765                         const ScMarkData& rMark, bool bNewSize, sal_uInt16 nNewFormatNo )
 766     :   ScBlockUndo( pNewDocShell, rRange, bNewSize ? SC_UNDO_MANUALHEIGHT : SC_UNDO_AUTOHEIGHT ),
 767         pUndoDoc    ( std::move(pNewUndoDoc) ),
 768         aMarkData   ( rMark ),
 769         bSize       ( bNewSize ),
 770         nFormatNo   ( nNewFormatNo )
 771 {
 772 }
 773
 774 ScUndoAutoFormat::~ScUndoAutoFormat()
 775 {
 776 }
 777
 778 OUString ScUndoAutoFormat::GetComment() const
 779 {
 780     return ScResId( STR_UNDO_AUTOFORMAT );   //"Auto-Format"
 781 }
 782
 783 void ScUndoAutoFormat::Undo()
 784 {
 785     BeginUndo();
 786
 787     ScDocument& rDoc = pDocShell->GetDocument();
 788
 789     SCTAB nTabCount = rDoc.GetTableCount();
 790     rDoc.DeleteArea( aBlockRange.aStart.Col(), aBlockRange.aStart.Row(),
 791                       aBlockRange.aEnd.Col(), aBlockRange.aEnd.Row(),
 792                       aMarkData, InsertDeleteFlags::ATTRIB );
 793     ScRange aCopyRange = aBlockRange;
 794     aCopyRange.aStart.SetTab(0);
 795     aCopyRange.aEnd.SetTab(nTabCount-1);
 796     pUndoDoc->CopyToDocument(aCopyRange, InsertDeleteFlags::ATTRIB, false, rDoc, &aMarkData);
 797
 798     // cell heights and widths (InsertDeleteFlags::NONE)
 799     if (bSize)
 800     {
 801         SCCOL nStartX = aBlockRange.aStart.Col();
 802         SCROW nStartY = aBlockRange.aStart.Row();
 803         SCTAB nStartZ = aBlockRange.aStart.Tab();
 804         SCCOL nEndX = aBlockRange.aEnd.Col();
 805         SCROW nEndY = aBlockRange.aEnd.Row();
 806         SCTAB nEndZ = aBlockRange.aEnd.Tab();
 807
 808         pUndoDoc->CopyToDocument( nStartX, 0, 0, nEndX, rDoc.MaxRow(), nTabCount-1,
 809                                     InsertDeleteFlags::NONE, false, rDoc, &aMarkData );
 810         pUndoDoc->CopyToDocument( 0, nStartY, 0, rDoc.MaxCol(), nEndY, nTabCount-1,
 811                                     InsertDeleteFlags::NONE, false, rDoc, &aMarkData );
 812         pDocShell->PostPaint( 0, 0, nStartZ, rDoc.MaxCol(), rDoc.MaxRow(), nEndZ,
 813                               PaintPartFlags::Grid | PaintPartFlags::Left | PaintPartFlags::Top, SC_PF_LINES );
 814     }
 815     else
 816         pDocShell->PostPaint( aBlockRange, PaintPartFlags::Grid, SC_PF_LINES );
 817
 818     EndUndo();
 819 }
 820
 821 void ScUndoAutoFormat::Redo()
 822 {
 823     BeginRedo();
 824
 825     ScDocument& rDoc = pDocShell->GetDocument();
 826
 827     SCCOL nStartX = aBlockRange.aStart.Col();
 828     SCROW nStartY = aBlockRange.aStart.Row();
 829     SCTAB nStartZ = aBlockRange.aStart.Tab();
 830     SCCOL nEndX = aBlockRange.aEnd.Col();
 831     SCROW nEndY = aBlockRange.aEnd.Row();
 832     SCTAB nEndZ = aBlockRange.aEnd.Tab();
 833
 834     rDoc.AutoFormat( nStartX, nStartY, nEndX, nEndY, nFormatNo, aMarkData );
 835
 836     if (bSize)
 837     {
 838         ScopedVclPtrInstance< VirtualDevice > pVirtDev;
 839         Fraction aZoomX(1,1);
 840         Fraction aZoomY = aZoomX;
 841         double nPPTX,nPPTY;
 842         ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 843         if (pViewShell)
 844         {
 845             ScViewData& rData = pViewShell->GetViewData();
 846             nPPTX = rData.GetPPTX();
 847             nPPTY = rData.GetPPTY();
 848             aZoomX = rData.GetZoomX();
 849             aZoomY = rData.GetZoomY();
 850         }
 851         else
 852         {
 853             // Keep zoom at 100
 854             nPPTX = ScGlobal::nScreenPPTX;
 855             nPPTY = ScGlobal::nScreenPPTY;
 856         }
 857
 858         sc::RowHeightContext aCxt(rDoc.MaxRow(), nPPTX, nPPTY, aZoomX, aZoomY, pVirtDev);
 859         for (SCTAB nTab=nStartZ; nTab<=nEndZ; nTab++)
 860         {
 861             ScMarkData aDestMark(rDoc.GetSheetLimits());
 862             aDestMark.SelectOneTable( nTab );
 863             aDestMark.SetMarkArea( ScRange( nStartX, nStartY, nTab, nEndX, nEndY, nTab ) );
 864             aDestMark.MarkToMulti();
 865
 866             // as SC_SIZE_VISOPT
 867             for (SCROW nRow=nStartY; nRow<=nEndY; nRow++)
 868             {
 869                 CRFlags nOld = rDoc.GetRowFlags(nRow,nTab);
 870                 bool bHidden = rDoc.RowHidden(nRow, nTab);
 871                 if ( !bHidden && ( nOld & CRFlags::ManualSize ) )
 872                     rDoc.SetRowFlags( nRow, nTab, nOld & ~CRFlags::ManualSize );
 873             }
 874
 875             bool bChanged = rDoc.SetOptimalHeight(aCxt, nStartY, nEndY, nTab, true);
 876
 877             for (SCCOL nCol=nStartX; nCol<=nEndX; nCol++)
 878                 if (!rDoc.ColHidden(nCol, nTab))
 879                 {
 880                     sal_uInt16 nThisSize = STD_EXTRA_WIDTH + rDoc.GetOptimalColWidth( nCol, nTab,
 881                                                 pVirtDev, nPPTX, nPPTY, aZoomX, aZoomY, false/*bFormula*/,
 882                                                 &aDestMark );
 883                     rDoc.SetColWidth( nCol, nTab, nThisSize );
 884                     rDoc.ShowCol( nCol, nTab, true );
 885                 }
 886
 887             // tdf#76183: recalculate objects' positions
 888             if (bChanged)
 889                 rDoc.SetDrawPageSize(nTab);
 890         }
 891
 892         pDocShell->PostPaint( 0,      0,      nStartZ,
 893                               rDoc.MaxCol(), rDoc.MaxRow(), nEndZ,
 894                               PaintPartFlags::Grid | PaintPartFlags::Left | PaintPartFlags::Top, SC_PF_LINES);
 895     }
 896     else
 897         pDocShell->PostPaint( aBlockRange, PaintPartFlags::Grid, SC_PF_LINES );
 898
 899     EndRedo();
 900 }
 901
 902 void ScUndoAutoFormat::Repeat(SfxRepeatTarget& rTarget)
 903 {
 904     if (auto pViewTarget = dynamic_cast<ScTabViewTarget*>( &rTarget))
 905         pViewTarget->GetViewShell()->AutoFormat( nFormatNo );
 906 }
 907
 908 bool ScUndoAutoFormat::CanRepeat(SfxRepeatTarget& rTarget) const
 909 {
 910     return dynamic_cast<const ScTabViewTarget*>( &rTarget) !=  nullptr;
 911 }
 912
 913 ScUndoReplace::ScUndoReplace( ScDocShell* pNewDocShell, const ScMarkData& rMark,
 914                                     SCCOL nCurX, SCROW nCurY, SCTAB nCurZ,
 915                                     OUString aNewUndoStr, ScDocumentUniquePtr pNewUndoDoc,
 916                                     const SvxSearchItem* pItem )
 917     :   ScSimpleUndo( pNewDocShell ),
 918         aCursorPos  ( nCurX, nCurY, nCurZ ),
 919         aMarkData   ( rMark ),
 920         aUndoStr    (std::move( aNewUndoStr )),
 921         pUndoDoc    ( std::move(pNewUndoDoc) )
 922 {
 923     pSearchItem.reset( new SvxSearchItem( *pItem ) );
 924     SetChangeTrack();
 925 }
 926
 927 ScUndoReplace::~ScUndoReplace()
 928 {
 929     pUndoDoc.reset();
 930     pSearchItem.reset();
 931 }
 932
 933 void ScUndoReplace::SetChangeTrack()
 934 {
 935     ScDocument& rDoc = pDocShell->GetDocument();
 936     ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
 937     if ( pChangeTrack )
 938     {
 939         if ( pUndoDoc )
 940         {   //! UndoDoc includes only the changed cells,
 941             // that is why an Iterator can be used
 942             pChangeTrack->AppendContentsIfInRefDoc( *pUndoDoc,
 943                 nStartChangeAction, nEndChangeAction );
 944         }
 945         else
 946         {
 947             nStartChangeAction = pChangeTrack->GetActionMax() + 1;
 948             ScChangeActionContent* pContent = new ScChangeActionContent(
 949                 ScRange( aCursorPos) );
 950             ScCellValue aCell;
 951             aCell.assign(rDoc, aCursorPos);
 952             pContent->SetOldValue( aUndoStr, &rDoc );
 953             pContent->SetNewValue(aCell, &rDoc);
 954             pChangeTrack->Append( pContent );
 955             nEndChangeAction = pChangeTrack->GetActionMax();
 956         }
 957     }
 958     else
 959         nStartChangeAction = nEndChangeAction = 0;
 960 }
 961
 962 OUString ScUndoReplace::GetComment() const
 963 {
 964     return ScResId( STR_UNDO_REPLACE );  // "Replace"
 965 }
 966
 967 void ScUndoReplace::Undo()
 968 {
 969     BeginUndo();
 970
 971     ScDocument& rDoc = pDocShell->GetDocument();
 972     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 973
 974     ShowTable( aCursorPos.Tab() );
 975
 976     if (pUndoDoc)       // only for ReplaceAll !!
 977     {
 978         OSL_ENSURE(pSearchItem->GetCommand() == SvxSearchCmd::REPLACE_ALL,
 979                    "ScUndoReplace:: Wrong Mode");
 980
 981         SetViewMarkData( aMarkData );
 982
 983 //! selected sheet
 984 //! select range ?
 985
 986         // Undo document has no row/column information, thus copy with
 987         // bColRowFlags = FALSE to not destroy Outline groups
 988
 989         InsertDeleteFlags nUndoFlags = (pSearchItem->GetPattern()) ? InsertDeleteFlags::ATTRIB : InsertDeleteFlags::CONTENTS;
 990         pUndoDoc->CopyToDocument( 0,      0,      0,
 991                                   rDoc.MaxCol(), rDoc.MaxRow(), MAXTAB,
 992                                   nUndoFlags, false, rDoc, nullptr, false );   // without row flags
 993         pDocShell->PostPaintGridAll();
 994     }
 995     else if (pSearchItem->GetPattern() &&
 996              pSearchItem->GetCommand() == SvxSearchCmd::REPLACE)
 997     {
 998         OUString aTempStr = pSearchItem->GetSearchString();       // toggle
 999         pSearchItem->SetSearchString(pSearchItem->GetReplaceString());
1000         pSearchItem->SetReplaceString(aTempStr);
1001         rDoc.ReplaceStyle( *pSearchItem,
1002                             aCursorPos.Col(), aCursorPos.Row(), aCursorPos.Tab(),
1003                             aMarkData);
1004         pSearchItem->SetReplaceString(pSearchItem->GetSearchString());
1005         pSearchItem->SetSearchString(aTempStr);
1006         if (pViewShell)
1007             pViewShell->MoveCursorAbs( aCursorPos.Col(), aCursorPos.Row(),
1008                                        SC_FOLLOW_JUMP, false, false );
1009         pDocShell->PostPaintGridAll();
1010     }
1011     else if (pSearchItem->GetCellType() == SvxSearchCellType::NOTE)
1012     {
1013         ScPostIt* pNote = rDoc.GetNote(aCursorPos);
1014         OSL_ENSURE( pNote, "ScUndoReplace::Undo - cell does not contain a note" );
1015         if (pNote)
1016             pNote->SetText( aCursorPos, aUndoStr );
1017         if (pViewShell)
1018             pViewShell->MoveCursorAbs( aCursorPos.Col(), aCursorPos.Row(),
1019                                        SC_FOLLOW_JUMP, false, false );
1020     }
1021     else
1022     {
1023         // aUndoStr may contain line breaks
1024         if ( aUndoStr.indexOf('\n') != -1 )
1025         {
1026             ScFieldEditEngine& rEngine = rDoc.GetEditEngine();
1027             rEngine.SetTextCurrentDefaults(aUndoStr);
1028             rDoc.SetEditText(aCursorPos, rEngine.CreateTextObject());
1029         }
1030         else
1031             rDoc.SetString( aCursorPos.Col(), aCursorPos.Row(), aCursorPos.Tab(), aUndoStr );
1032         if (pViewShell)
1033             pViewShell->MoveCursorAbs( aCursorPos.Col(), aCursorPos.Row(),
1034                                        SC_FOLLOW_JUMP, false, false );
1035         pDocShell->PostPaintGridAll();
1036     }
1037
1038     ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
1039     if ( pChangeTrack )
1040         pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
1041
1042     EndUndo();
1043 }
1044
1045 void ScUndoReplace::Redo()
1046 {
1047     BeginRedo();
1048
1049     ScDocument& rDoc = pDocShell->GetDocument();
1050     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1051
1052     if (pViewShell)
1053         pViewShell->MoveCursorAbs( aCursorPos.Col(), aCursorPos.Row(),
1054                                    SC_FOLLOW_JUMP, false, false );
1055     if (pUndoDoc)
1056     {
1057         if (pViewShell)
1058         {
1059             SetViewMarkData( aMarkData );
1060
1061             pViewShell->SearchAndReplace( pSearchItem.get(), false, true );
1062         }
1063     }
1064     else if (pSearchItem->GetPattern() &&
1065              pSearchItem->GetCommand() == SvxSearchCmd::REPLACE)
1066     {
1067         rDoc.ReplaceStyle( *pSearchItem,
1068                             aCursorPos.Col(), aCursorPos.Row(), aCursorPos.Tab(),
1069                             aMarkData);
1070         pDocShell->PostPaintGridAll();
1071     }
1072     else
1073         if (pViewShell)
1074             pViewShell->SearchAndReplace( pSearchItem.get(), false, true );
1075
1076     SetChangeTrack();
1077
1078     EndRedo();
1079 }
1080
1081 void ScUndoReplace::Repeat(SfxRepeatTarget& rTarget)
1082 {
1083     if (auto pViewTarget = dynamic_cast<ScTabViewTarget*>( &rTarget))
1084         pViewTarget->GetViewShell()->SearchAndReplace( pSearchItem.get(), true, false );
1085 }
1086
1087 bool ScUndoReplace::CanRepeat(SfxRepeatTarget& rTarget) const
1088 {
1089     return dynamic_cast<const ScTabViewTarget*>( &rTarget) !=  nullptr;
1090 }
1091
1092 // multi-operation (only simple blocks)
1093 ScUndoTabOp::ScUndoTabOp( ScDocShell* pNewDocShell,
1094                 SCCOL nStartX, SCROW nStartY, SCTAB nStartZ,
1095                 SCCOL nEndX, SCROW nEndY, SCTAB nEndZ, ScDocumentUniquePtr pNewUndoDoc,
1096                 const ScRefAddress& rFormulaCell,
1097                 const ScRefAddress& rFormulaEnd,
1098                 const ScRefAddress& rRowCell,
1099                 const ScRefAddress& rColCell,
1100                 ScTabOpParam::Mode eMode )
1101     :   ScSimpleUndo( pNewDocShell ),
1102         aRange          ( nStartX, nStartY, nStartZ, nEndX, nEndY, nEndZ ),
1103         pUndoDoc        ( std::move(pNewUndoDoc) ),
1104         theFormulaCell  ( rFormulaCell ),
1105         theFormulaEnd   ( rFormulaEnd ),
1106         theRowCell      ( rRowCell ),
1107         theColCell      ( rColCell ),
1108         meMode(eMode)
1109 {
1110 }
1111
1112 ScUndoTabOp::~ScUndoTabOp()
1113 {
1114 }
1115
1116 OUString ScUndoTabOp::GetComment() const
1117 {
1118     return ScResId( STR_UNDO_TABOP );    // "Multiple operation"
1119 }
1120
1121 void ScUndoTabOp::Undo()
1122 {
1123     BeginUndo();
1124
1125     ScUndoUtil::MarkSimpleBlock( pDocShell, aRange );
1126
1127     sal_uInt16 nExtFlags = 0;
1128     pDocShell->UpdatePaintExt( nExtFlags, aRange );
1129
1130     ScDocument& rDoc = pDocShell->GetDocument();
1131     rDoc.DeleteAreaTab( aRange,InsertDeleteFlags::ALL & ~InsertDeleteFlags::NOTE );
1132     pUndoDoc->CopyToDocument( aRange, InsertDeleteFlags::ALL & ~InsertDeleteFlags::NOTE, false, rDoc );
1133     pDocShell->PostPaint( aRange, PaintPartFlags::Grid, nExtFlags );
1134     pDocShell->PostDataChanged();
1135     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1136     if (pViewShell)
1137         pViewShell->CellContentChanged();
1138
1139     EndUndo();
1140 }
1141
1142 void ScUndoTabOp::Redo()
1143 {
1144     BeginRedo();
1145
1146     ScUndoUtil::MarkSimpleBlock( pDocShell, aRange );
1147
1148     ScTabOpParam aParam(theFormulaCell, theFormulaEnd, theRowCell, theColCell, meMode);
1149
1150     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1151     if (pViewShell)
1152         pViewShell->TabOp( aParam, false);
1153
1154     EndRedo();
1155 }
1156
1157 void ScUndoTabOp::Repeat(SfxRepeatTarget& /* rTarget */)
1158 {
1159 }
1160
1161 bool ScUndoTabOp::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1162 {
1163     return false;
1164 }
1165
1166 ScUndoConversion::ScUndoConversion(
1167         ScDocShell* pNewDocShell, const ScMarkData& rMark,
1168         SCCOL nCurX, SCROW nCurY, SCTAB nCurZ, ScDocumentUniquePtr pNewUndoDoc,
1169         SCCOL nNewX, SCROW nNewY, SCTAB nNewZ, ScDocumentUniquePtr pNewRedoDoc,
1170         ScConversionParam aConvParam ) :
1171     ScSimpleUndo( pNewDocShell ),
1172     aMarkData( rMark ),
1173     aCursorPos( nCurX, nCurY, nCurZ ),
1174     pUndoDoc( std::move(pNewUndoDoc) ),
1175     aNewCursorPos( nNewX, nNewY, nNewZ ),
1176     pRedoDoc( std::move(pNewRedoDoc) ),
1177     maConvParam(std::move( aConvParam ))
1178 {
1179     SetChangeTrack();
1180 }
1181
1182 ScUndoConversion::~ScUndoConversion()
1183 {
1184     pUndoDoc.reset();
1185     pRedoDoc.reset();
1186 }
1187
1188 void ScUndoConversion::SetChangeTrack()
1189 {
1190     ScDocument& rDoc = pDocShell->GetDocument();
1191     ScChangeTrack* pChangeTrack = rDoc.GetChangeTrack();
1192     if ( pChangeTrack )
1193     {
1194         if ( pUndoDoc )
1195             pChangeTrack->AppendContentsIfInRefDoc( *pUndoDoc,
1196                 nStartChangeAction, nEndChangeAction );
1197         else
1198         {
1199             OSL_FAIL( "ScUndoConversion::SetChangeTrack: no UndoDoc" );
1200             nStartChangeAction = nEndChangeAction = 0;
1201         }
1202     }
1203     else
1204         nStartChangeAction = nEndChangeAction = 0;
1205 }
1206
1207 OUString ScUndoConversion::GetComment() const
1208 {
1209     OUString aText;
1210     switch( maConvParam.GetType() )
1211     {
1212         case SC_CONVERSION_SPELLCHECK:      aText = ScResId( STR_UNDO_SPELLING );    break;
1213         case SC_CONVERSION_HANGULHANJA:     aText = ScResId( STR_UNDO_HANGULHANJA ); break;
1214         case SC_CONVERSION_CHINESE_TRANSL:  aText = ScResId( STR_UNDO_CHINESE_TRANSLATION ); break;
1215     }
1216     return aText;
1217 }
1218
1219 void ScUndoConversion::DoChange( ScDocument* pRefDoc, const ScAddress& rCursorPos )
1220 {
1221     if (pRefDoc)
1222     {
1223         ScDocument& rDoc = pDocShell->GetDocument();
1224         ShowTable( rCursorPos.Tab() );
1225
1226         SetViewMarkData( aMarkData );
1227
1228         SCTAB nTabCount = rDoc.GetTableCount();
1229         //  Undo/Redo-doc has only selected tables
1230
1231         bool bMulti = aMarkData.IsMultiMarked();
1232         pRefDoc->CopyToDocument( 0,      0,      0,
1233                                  rDoc.MaxCol(), rDoc.MaxRow(), nTabCount-1,
1234                                  InsertDeleteFlags::CONTENTS, bMulti, rDoc, &aMarkData );
1235
1236         // Reset the spell checking results to re-check on paint, otherwise
1237         // we show the previous spelling markers (or lack thereof on misspellings).
1238         if (ScViewData* pViewData = ScDocShell::GetViewData())
1239             pViewData->GetActiveWin()->ResetAutoSpell();
1240         pDocShell->PostPaintGridAll();
1241     }
1242     else
1243     {
1244         OSL_FAIL("no Un-/RedoDoc for Un-/RedoSpelling");
1245     }
1246 }
1247
1248 void ScUndoConversion::Undo()
1249 {
1250     BeginUndo();
1251     DoChange( pUndoDoc.get(), aCursorPos );
1252     ScChangeTrack* pChangeTrack = pDocShell->GetDocument().GetChangeTrack();
1253     if ( pChangeTrack )
1254         pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
1255     EndUndo();
1256 }
1257
1258 void ScUndoConversion::Redo()
1259 {
1260     BeginRedo();
1261     DoChange( pRedoDoc.get(), aNewCursorPos );
1262     SetChangeTrack();
1263     EndRedo();
1264 }
1265
1266 void ScUndoConversion::Repeat( SfxRepeatTarget& rTarget )
1267 {
1268     if( auto pViewTarget = dynamic_cast<ScTabViewTarget*>( &rTarget) )
1269         pViewTarget->GetViewShell()->DoSheetConversion( maConvParam );
1270 }
1271
1272 bool ScUndoConversion::CanRepeat(SfxRepeatTarget& rTarget) const
1273 {
1274     return dynamic_cast<const ScTabViewTarget*>( &rTarget) !=  nullptr;
1275 }
1276
1277 ScUndoRefConversion::ScUndoRefConversion( ScDocShell* pNewDocShell,
1278                                          const ScRange& aMarkRange, const ScMarkData& rMark,
1279                                          ScDocumentUniquePtr pNewUndoDoc, ScDocumentUniquePtr pNewRedoDoc, bool bNewMulti) :
1280 ScSimpleUndo( pNewDocShell ),
1281 aMarkData   ( rMark ),
1282 pUndoDoc    ( std::move(pNewUndoDoc) ),
1283 pRedoDoc    ( std::move(pNewRedoDoc) ),
1284 aRange      ( aMarkRange ),
1285 bMulti      ( bNewMulti )
1286 {
1287     assert(pUndoDoc && pRedoDoc);
1288     SetChangeTrack();
1289 }
1290
1291 ScUndoRefConversion::~ScUndoRefConversion()
1292 {
1293     pUndoDoc.reset();
1294     pRedoDoc.reset();
1295 }
1296
1297 OUString ScUndoRefConversion::GetComment() const
1298 {
1299     return ScResId( STR_UNDO_ENTERDATA ); // "Input"
1300 }
1301
1302 void ScUndoRefConversion::SetChangeTrack()
1303 {
1304     ScChangeTrack* pChangeTrack = pDocShell->GetDocument().GetChangeTrack();
1305     if ( pChangeTrack )
1306         pChangeTrack->AppendContentsIfInRefDoc( *pUndoDoc,
1307             nStartChangeAction, nEndChangeAction );
1308     else
1309         nStartChangeAction = nEndChangeAction = 0;
1310 }
1311
1312 void ScUndoRefConversion::DoChange( ScDocument* pRefDoc)
1313 {
1314     ScDocument& rDoc = pDocShell->GetDocument();
1315
1316     ShowTable(aRange);
1317
1318     SetViewMarkData( aMarkData );
1319
1320     ScRange aCopyRange = aRange;
1321     SCTAB nTabCount = rDoc.GetTableCount();
1322     aCopyRange.aStart.SetTab(0);
1323     aCopyRange.aEnd.SetTab(nTabCount-1);
1324     pRefDoc->CopyToDocument( aCopyRange, InsertDeleteFlags::ALL, bMulti, rDoc, &aMarkData );
1325     pDocShell->PostPaint( aRange, PaintPartFlags::Grid);
1326     pDocShell->PostDataChanged();
1327     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1328     if (pViewShell)
1329         pViewShell->CellContentChanged();
1330 }
1331
1332 void ScUndoRefConversion::Undo()
1333 {
1334     BeginUndo();
1335     if (pUndoDoc)
1336         DoChange(pUndoDoc.get());
1337     ScChangeTrack* pChangeTrack = pDocShell->GetDocument().GetChangeTrack();
1338     if ( pChangeTrack )
1339         pChangeTrack->Undo( nStartChangeAction, nEndChangeAction );
1340     EndUndo();
1341 }
1342
1343 void ScUndoRefConversion::Redo()
1344 {
1345     BeginRedo();
1346     if (pRedoDoc)
1347         DoChange(pRedoDoc.get());
1348     SetChangeTrack();
1349     EndRedo();
1350 }
1351
1352 void ScUndoRefConversion::Repeat(SfxRepeatTarget& rTarget)
1353 {
1354     if (auto pViewTarget = dynamic_cast<ScTabViewTarget*>( &rTarget))
1355         pViewTarget->GetViewShell()->DoRefConversion();
1356 }
1357
1358 bool ScUndoRefConversion::CanRepeat(SfxRepeatTarget& rTarget) const
1359 {
1360     return dynamic_cast<const ScTabViewTarget*>( &rTarget) !=  nullptr;
1361 }
1362
1363 ScUndoRefreshLink::ScUndoRefreshLink(ScDocShell* pNewDocShell,
1364                                      ScDocumentUniquePtr pNewUndoDoc)
1365     : ScSimpleUndo(pNewDocShell)
1366     , xUndoDoc(std::move(pNewUndoDoc))
1367 {
1368 }
1369
1370 OUString ScUndoRefreshLink::GetComment() const
1371 {
1372     return ScResId( STR_UNDO_UPDATELINK );
1373 }
1374
1375 void ScUndoRefreshLink::Undo()
1376 {
1377     BeginUndo();
1378
1379     bool bMakeRedo = !xRedoDoc;
1380     if (bMakeRedo)
1381         xRedoDoc.reset(new ScDocument(SCDOCMODE_UNDO));
1382
1383     bool bFirst = true;
1384     ScDocument& rDoc = pDocShell->GetDocument();
1385     SCTAB nCount = rDoc.GetTableCount();
1386     for (SCTAB nTab=0; nTab<nCount; nTab++)
1387         if (xUndoDoc->HasTable(nTab))
1388         {
1389             ScRange aRange(0,0,nTab,rDoc.MaxCol(),rDoc.MaxRow(),nTab);
1390             if (bMakeRedo)
1391             {
1392                 if (bFirst)
1393                     xRedoDoc->InitUndo(rDoc, nTab, nTab, true, true);
1394                 else
1395                     xRedoDoc->AddUndoTab(nTab, nTab, true, true);
1396                 bFirst = false;
1397                 rDoc.CopyToDocument(aRange, InsertDeleteFlags::ALL, false, *xRedoDoc);
1398                 xRedoDoc->SetLink(nTab,
1399                                   rDoc.GetLinkMode(nTab),
1400                                   rDoc.GetLinkDoc(nTab),
1401                                   rDoc.GetLinkFlt(nTab),
1402                                   rDoc.GetLinkOpt(nTab),
1403                                   rDoc.GetLinkTab(nTab),
1404                                   rDoc.GetLinkRefreshDelay(nTab));
1405                 xRedoDoc->SetTabBgColor( nTab, rDoc.GetTabBgColor(nTab) );
1406             }
1407
1408             rDoc.DeleteAreaTab( aRange,InsertDeleteFlags::ALL );
1409             xUndoDoc->CopyToDocument(aRange, InsertDeleteFlags::ALL, false, rDoc);
1410             rDoc.SetLink(nTab, xUndoDoc->GetLinkMode(nTab), xUndoDoc->GetLinkDoc(nTab),
1411                                xUndoDoc->GetLinkFlt(nTab),  xUndoDoc->GetLinkOpt(nTab),
1412                                xUndoDoc->GetLinkTab(nTab),
1413                                xUndoDoc->GetLinkRefreshDelay(nTab) );
1414             rDoc.SetTabBgColor(nTab, xUndoDoc->GetTabBgColor(nTab));
1415         }
1416
1417     pDocShell->PostPaintGridAll();
1418     pDocShell->PostPaintExtras();
1419
1420     EndUndo();
1421 }
1422
1423 void ScUndoRefreshLink::Redo()
1424 {
1425     OSL_ENSURE(xRedoDoc, "No RedoDoc for ScUndoRefreshLink::Redo");
1426
1427     BeginUndo();
1428
1429     ScDocument& rDoc = pDocShell->GetDocument();
1430     SCTAB nCount = rDoc.GetTableCount();
1431     for (SCTAB nTab=0; nTab<nCount; nTab++)
1432         if (xRedoDoc->HasTable(nTab))
1433         {
1434             ScRange aRange(0,0,nTab,rDoc.MaxCol(),rDoc.MaxRow(),nTab);
1435
1436             rDoc.DeleteAreaTab( aRange, InsertDeleteFlags::ALL );
1437             xRedoDoc->CopyToDocument(aRange, InsertDeleteFlags::ALL, false, rDoc);
1438             rDoc.SetLink(nTab,
1439                          xRedoDoc->GetLinkMode(nTab),
1440                          xRedoDoc->GetLinkDoc(nTab),
1441                          xRedoDoc->GetLinkFlt(nTab),
1442                          xRedoDoc->GetLinkOpt(nTab),
1443                          xRedoDoc->GetLinkTab(nTab),
1444                          xRedoDoc->GetLinkRefreshDelay(nTab) );
1445             rDoc.SetTabBgColor(nTab, xRedoDoc->GetTabBgColor(nTab));
1446         }
1447
1448     pDocShell->PostPaintGridAll();
1449     pDocShell->PostPaintExtras();
1450
1451     EndUndo();
1452 }
1453
1454 void ScUndoRefreshLink::Repeat(SfxRepeatTarget& /* rTarget */)
1455 {
1456     // makes no sense
1457 }
1458
1459 bool ScUndoRefreshLink::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1460 {
1461     return false;
1462 }
1463
1464 static ScAreaLink* lcl_FindAreaLink( const sfx2::LinkManager* pLinkManager, std::u16string_view rDoc,
1465                             std::u16string_view rFlt, std::u16string_view rOpt,
1466                             std::u16string_view rSrc, const ScRange& rDest )
1467 {
1468     const ::sfx2::SvBaseLinks& rLinks = pLinkManager->GetLinks();
1469     sal_uInt16 nCount = pLinkManager->GetLinks().size();
1470     for (sal_uInt16 i=0; i<nCount; i++)
1471     {
1472         ::sfx2::SvBaseLink* pBase = rLinks[i].get();
1473         if (auto pAreaLink = dynamic_cast<ScAreaLink*>( pBase))
1474             if ( pAreaLink->IsEqual( rDoc, rFlt, rOpt, rSrc, rDest ) )
1475                 return pAreaLink;
1476     }
1477
1478     OSL_FAIL("ScAreaLink not found");
1479     return nullptr;
1480 }
1481
1482 ScUndoInsertAreaLink::ScUndoInsertAreaLink( ScDocShell* pShell,
1483                             OUString aDoc,
1484                             OUString aFlt, OUString aOpt,
1485                             OUString aArea, const ScRange& rDestRange,
1486                             sal_uLong nRefresh )
1487     :   ScSimpleUndo    ( pShell ),
1488         aDocName        (std::move( aDoc )),
1489         aFltName        (std::move( aFlt )),
1490         aOptions        (std::move( aOpt )),
1491         aAreaName       (std::move( aArea )),
1492         aRange          ( rDestRange ),
1493         nRefreshDelay   ( nRefresh )
1494 {
1495 }
1496
1497 ScUndoInsertAreaLink::~ScUndoInsertAreaLink()
1498 {
1499 }
1500
1501 OUString ScUndoInsertAreaLink::GetComment() const
1502 {
1503     return ScResId( STR_UNDO_INSERTAREALINK );
1504 }
1505
1506 void ScUndoInsertAreaLink::Undo()
1507 {
1508     ScDocument& rDoc = pDocShell->GetDocument();
1509     sfx2::LinkManager* pLinkManager = rDoc.GetLinkManager();
1510
1511     ScAreaLink* pLink = lcl_FindAreaLink( pLinkManager, aDocName, aFltName, aOptions,
1512                                             aAreaName, aRange );
1513     if (pLink)
1514         pLinkManager->Remove( pLink );
1515
1516     SfxGetpApp()->Broadcast( SfxHint( SfxHintId::ScAreaLinksChanged ) );     // Navigator
1517 }
1518
1519 void ScUndoInsertAreaLink::Redo()
1520 {
1521     ScDocument& rDoc = pDocShell->GetDocument();
1522     sfx2::LinkManager* pLinkManager = rDoc.GetLinkManager();
1523
1524     ScAreaLink* pLink = new ScAreaLink( pDocShell, aDocName, aFltName, aOptions,
1525                                             aAreaName, ScRange(aRange.aStart), nRefreshDelay );
1526     pLink->SetInCreate( true );
1527     pLink->SetDestArea( aRange );
1528     pLinkManager->InsertFileLink( *pLink, sfx2::SvBaseLinkObjectType::ClientFile, aDocName, &aFltName, &aAreaName );
1529     pLink->Update();
1530     pLink->SetInCreate( false );
1531
1532     SfxGetpApp()->Broadcast( SfxHint( SfxHintId::ScAreaLinksChanged ) );     // Navigator
1533 }
1534
1535 void ScUndoInsertAreaLink::Repeat(SfxRepeatTarget& /* rTarget */)
1536 {
1537     // makes no sense
1538 }
1539
1540 bool ScUndoInsertAreaLink::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1541 {
1542     return false;
1543 }
1544
1545 ScUndoRemoveAreaLink::ScUndoRemoveAreaLink( ScDocShell* pShell,
1546                             OUString aDoc, OUString aFlt, OUString aOpt,
1547                             OUString aArea, const ScRange& rDestRange,
1548                             sal_uLong nRefresh )
1549     :   ScSimpleUndo    ( pShell ),
1550         aDocName        (std::move( aDoc )),
1551         aFltName        (std::move( aFlt )),
1552         aOptions        (std::move( aOpt )),
1553         aAreaName       (std::move( aArea )),
1554         aRange          ( rDestRange ),
1555         nRefreshDelay   ( nRefresh )
1556 {
1557 }
1558
1559 ScUndoRemoveAreaLink::~ScUndoRemoveAreaLink()
1560 {
1561 }
1562
1563 OUString ScUndoRemoveAreaLink::GetComment() const
1564 {
1565     return ScResId( STR_UNDO_REMOVELINK );   //! own text ??
1566 }
1567
1568 void ScUndoRemoveAreaLink::Undo()
1569 {
1570     ScDocument& rDoc = pDocShell->GetDocument();
1571     sfx2::LinkManager* pLinkManager = rDoc.GetLinkManager();
1572
1573     ScAreaLink* pLink = new ScAreaLink( pDocShell, aDocName, aFltName, aOptions,
1574                                         aAreaName, ScRange(aRange.aStart), nRefreshDelay );
1575     pLink->SetInCreate( true );
1576     pLink->SetDestArea( aRange );
1577     pLinkManager->InsertFileLink( *pLink, sfx2::SvBaseLinkObjectType::ClientFile, aDocName, &aFltName, &aAreaName );
1578     pLink->Update();
1579     pLink->SetInCreate( false );
1580
1581     SfxGetpApp()->Broadcast( SfxHint( SfxHintId::ScAreaLinksChanged ) );     // Navigator
1582 }
1583
1584 void ScUndoRemoveAreaLink::Redo()
1585 {
1586     ScDocument& rDoc = pDocShell->GetDocument();
1587     sfx2::LinkManager* pLinkManager = rDoc.GetLinkManager();
1588
1589     ScAreaLink* pLink = lcl_FindAreaLink( pLinkManager, aDocName, aFltName, aOptions,
1590                                             aAreaName, aRange );
1591     if (pLink)
1592         pLinkManager->Remove( pLink );
1593
1594     SfxGetpApp()->Broadcast( SfxHint( SfxHintId::ScAreaLinksChanged ) );     // Navigator
1595 }
1596
1597 void ScUndoRemoveAreaLink::Repeat(SfxRepeatTarget& /* rTarget */)
1598 {
1599     // makes no sense
1600 }
1601
1602 bool ScUndoRemoveAreaLink::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1603 {
1604     return false;
1605 }
1606
1607 ScUndoUpdateAreaLink::ScUndoUpdateAreaLink( ScDocShell* pShell,
1608                             OUString aOldD, OUString aOldF, OUString aOldO,
1609                             OUString aOldA, const ScRange& rOldR, sal_uLong nOldRD,
1610                             OUString aNewD, OUString aNewF, OUString aNewO,
1611                             OUString aNewA, const ScRange& rNewR, sal_uLong nNewRD,
1612                             ScDocumentUniquePtr pUndo, ScDocumentUniquePtr pRedo, bool bDoInsert )
1613     :   ScSimpleUndo( pShell ),
1614         aOldDoc     (std::move( aOldD )),
1615         aOldFlt     (std::move( aOldF )),
1616         aOldOpt     (std::move( aOldO )),
1617         aOldArea    (std::move( aOldA )),
1618         aOldRange   ( rOldR ),
1619         aNewDoc     (std::move( aNewD )),
1620         aNewFlt     (std::move( aNewF )),
1621         aNewOpt     (std::move( aNewO )),
1622         aNewArea    (std::move( aNewA )),
1623         aNewRange   ( rNewR ),
1624         xUndoDoc    ( std::move(pUndo) ),
1625         xRedoDoc    ( std::move(pRedo) ),
1626         nOldRefresh ( nOldRD ),
1627         nNewRefresh ( nNewRD ),
1628         bWithInsert ( bDoInsert )
1629 {
1630     OSL_ENSURE( aOldRange.aStart == aNewRange.aStart, "AreaLink moved ?" );
1631 }
1632
1633 OUString ScUndoUpdateAreaLink::GetComment() const
1634 {
1635     return ScResId( STR_UNDO_UPDATELINK );   //! own text ??
1636 }
1637
1638 void ScUndoUpdateAreaLink::DoChange( const bool bUndo ) const
1639 {
1640     ScDocument& rDoc = pDocShell->GetDocument();
1641
1642     SCCOL nEndX = std::max( aOldRange.aEnd.Col(), aNewRange.aEnd.Col() );
1643     SCROW nEndY = std::max( aOldRange.aEnd.Row(), aNewRange.aEnd.Row() );
1644     SCTAB nEndZ = std::max( aOldRange.aEnd.Tab(), aNewRange.aEnd.Tab() );    //?
1645
1646     if ( bUndo )
1647     {
1648         if ( bWithInsert )
1649         {
1650             rDoc.FitBlock( aNewRange, aOldRange );
1651             rDoc.DeleteAreaTab( aOldRange, InsertDeleteFlags::ALL & ~InsertDeleteFlags::NOTE );
1652             xUndoDoc->UndoToDocument(aOldRange, InsertDeleteFlags::ALL & ~InsertDeleteFlags::NOTE, false, rDoc);
1653         }
1654         else
1655         {
1656             ScRange aCopyRange( aOldRange.aStart, ScAddress(nEndX,nEndY,nEndZ) );
1657             rDoc.DeleteAreaTab( aCopyRange, InsertDeleteFlags::ALL & ~InsertDeleteFlags::NOTE );
1658             xUndoDoc->CopyToDocument(aCopyRange, InsertDeleteFlags::ALL & ~InsertDeleteFlags::NOTE, false, rDoc);
1659         }
1660     }
1661     else
1662     {
1663         if ( bWithInsert )
1664         {
1665             rDoc.FitBlock( aOldRange, aNewRange );
1666             rDoc.DeleteAreaTab( aNewRange, InsertDeleteFlags::ALL & ~InsertDeleteFlags::NOTE );
1667             xRedoDoc->CopyToDocument(aNewRange, InsertDeleteFlags::ALL & ~InsertDeleteFlags::NOTE, false, rDoc);
1668         }
1669         else
1670         {
1671             ScRange aCopyRange( aOldRange.aStart, ScAddress(nEndX,nEndY,nEndZ) );
1672             rDoc.DeleteAreaTab( aCopyRange, InsertDeleteFlags::ALL & ~InsertDeleteFlags::NOTE );
1673             xRedoDoc->CopyToDocument(aCopyRange, InsertDeleteFlags::ALL & ~InsertDeleteFlags::NOTE, false, rDoc);
1674         }
1675     }
1676
1677     ScRange aWorkRange( aNewRange.aStart, ScAddress( nEndX, nEndY, nEndZ ) );
1678     rDoc.ExtendMerge( aWorkRange, true );
1679
1680     //  Paint
1681
1682     if ( aNewRange.aEnd.Col() != aOldRange.aEnd.Col() )
1683         aWorkRange.aEnd.SetCol(rDoc.MaxCol());
1684     if ( aNewRange.aEnd.Row() != aOldRange.aEnd.Row() )
1685         aWorkRange.aEnd.SetRow(rDoc.MaxRow());
1686
1687     if ( !pDocShell->AdjustRowHeight( aWorkRange.aStart.Row(), aWorkRange.aEnd.Row(), aWorkRange.aStart.Tab() ) )
1688         pDocShell->PostPaint( aWorkRange, PaintPartFlags::Grid );
1689
1690     pDocShell->PostDataChanged();
1691     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
1692     if (pViewShell)
1693         pViewShell->CellContentChanged();
1694 }
1695
1696 void ScUndoUpdateAreaLink::Undo()
1697 {
1698     ScDocument& rDoc = pDocShell->GetDocument();
1699     sfx2::LinkManager* pLinkManager = rDoc.GetLinkManager();
1700     ScAreaLink* pLink = lcl_FindAreaLink( pLinkManager, aNewDoc, aNewFlt, aNewOpt,
1701                                             aNewArea, aNewRange );
1702     if (pLink)
1703     {
1704         pLink->SetSource( aOldDoc, aOldFlt, aOldOpt, aOldArea );        // old data in Link
1705         pLink->SetDestArea( aOldRange );
1706         pLink->SetRefreshDelay( nOldRefresh );
1707     }
1708
1709     DoChange(true);
1710 }
1711
1712 void ScUndoUpdateAreaLink::Redo()
1713 {
1714     ScDocument& rDoc = pDocShell->GetDocument();
1715     sfx2::LinkManager* pLinkManager = rDoc.GetLinkManager();
1716     ScAreaLink* pLink = lcl_FindAreaLink( pLinkManager, aOldDoc, aOldFlt, aOldOpt,
1717                                             aOldArea, aOldRange );
1718     if (pLink)
1719     {
1720         pLink->SetSource( aNewDoc, aNewFlt, aNewOpt, aNewArea );        // new values in link
1721         pLink->SetDestArea( aNewRange );
1722         pLink->SetRefreshDelay( nNewRefresh );
1723     }
1724
1725     DoChange(false);
1726 }
1727
1728 void ScUndoUpdateAreaLink::Repeat(SfxRepeatTarget& /* rTarget */)
1729 {
1730     // makes no sense
1731 }
1732
1733 bool ScUndoUpdateAreaLink::CanRepeat(SfxRepeatTarget& /* rTarget */) const
1734 {
1735     return false;
1736 }
1737
1738 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */