sc/source/ui/undo/undobase.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 <vcl/virdev.hxx>
  21
  22 #include "undobase.hxx"
  23 #include "refundo.hxx"
  24 #include "docsh.hxx"
  25 #include "tabvwsh.hxx"
  26 #include "undoolk.hxx"
  27 #include "undodraw.hxx"
  28 #include "dbdata.hxx"
  29 #include "attrib.hxx"
  30 #include "queryparam.hxx"
  31 #include "subtotalparam.hxx"
  32 #include "bcaslot.hxx"
  33 #include "globstr.hrc"
  34 #include <rowheightcontext.hxx>
  35 #include <column.hxx>
  36 #include <sortparam.hxx>
  37
  38 TYPEINIT1(ScSimpleUndo,     SfxUndoAction);
  39 TYPEINIT1(ScBlockUndo,      ScSimpleUndo);
  40 TYPEINIT1(ScMultiBlockUndo, ScSimpleUndo);
  41 TYPEINIT1(ScMoveUndo,       ScSimpleUndo);
  42 TYPEINIT1(ScDBFuncUndo,     ScSimpleUndo);
  43 TYPEINIT1(ScUndoWrapper,    SfxUndoAction);
  44
  45 ScSimpleUndo::ScSimpleUndo( ScDocShell* pDocSh ) :
  46     pDocShell( pDocSh ),
  47     pDetectiveUndo( NULL )
  48 {
  49 }
  50
  51 ScSimpleUndo::~ScSimpleUndo()
  52 {
  53     delete pDetectiveUndo;
  54 }
  55
  56 bool ScSimpleUndo::SetViewMarkData( const ScMarkData& rMarkData )
  57 {
  58     if ( IsPaintLocked() )
  59         return false;
  60
  61     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
  62     if ( !pViewShell )
  63         return false;
  64
  65     pViewShell->SetMarkData( rMarkData );
  66     return true;
  67 }
  68
  69 bool ScSimpleUndo::Merge( SfxUndoAction *pNextAction )
  70 {
  71     // A SdrUndoGroup for updating detective arrows can belong
  72     // to each Undo-Action.
  73     // DetectiveRefresh is always called next,
  74     // the SdrUndoGroup is encapsulated in a ScUndoDraw action.
  75     // AddUndoAction is only called with bTryMerg=sal_True
  76     // for automatic update.
  77
  78     if ( !pDetectiveUndo && pNextAction->ISA(ScUndoDraw) )
  79     {
  80         // Take SdrUndoAction from ScUndoDraw Action,
  81         // ScUndoDraw is later deleted by the UndoManager
  82
  83         ScUndoDraw* pCalcUndo = static_cast<ScUndoDraw*>(pNextAction);
  84         pDetectiveUndo = pCalcUndo->GetDrawUndo();
  85         pCalcUndo->ForgetDrawUndo();
  86         return true;
  87     }
  88
  89     return false;
  90 }
  91
  92 void ScSimpleUndo::BeginUndo()
  93 {
  94     pDocShell->SetInUndo( true );
  95
  96     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
  97     if (pViewShell)
  98         pViewShell->HideAllCursors();       // for example due to merged cells
  99
 100     //  detective updates happened last, must be undone first
 101     if (pDetectiveUndo)
 102         pDetectiveUndo->Undo();
 103 }
 104
 105 void ScSimpleUndo::EndUndo()
 106 {
 107     pDocShell->SetDocumentModified();
 108
 109     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 110     if (pViewShell)
 111     {
 112         pViewShell->UpdateAutoFillMark();
 113         pViewShell->UpdateInputHandler();
 114         pViewShell->ShowAllCursors();
 115     }
 116
 117     pDocShell->SetInUndo( false );
 118 }
 119
 120 void ScSimpleUndo::BeginRedo()
 121 {
 122     pDocShell->SetInUndo( true );   //! own Flag for Redo?
 123
 124     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 125     if (pViewShell)
 126         pViewShell->HideAllCursors();       // for example due to merged cells
 127 }
 128
 129 void ScSimpleUndo::EndRedo()
 130 {
 131     if (pDetectiveUndo)
 132         pDetectiveUndo->Redo();
 133
 134     pDocShell->SetDocumentModified();
 135
 136     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 137     if (pViewShell)
 138     {
 139         pViewShell->UpdateAutoFillMark();
 140         pViewShell->UpdateInputHandler();
 141         pViewShell->ShowAllCursors();
 142     }
 143
 144     pDocShell->SetInUndo( false );
 145 }
 146
 147 void ScSimpleUndo::BroadcastChanges( const ScRange& rRange )
 148 {
 149     ScDocument& rDoc = pDocShell->GetDocument();
 150     rDoc.BroadcastCells(rRange, SC_HINT_DATACHANGED);
 151 }
 152
 153 namespace {
 154
 155 class SpanBroadcaster : public sc::ColumnSpanSet::ColumnAction
 156 {
 157     ScDocument& mrDoc;
 158     SCTAB mnCurTab;
 159     SCCOL mnCurCol;
 160
 161 public:
 162     SpanBroadcaster( ScDocument& rDoc ) : mrDoc(rDoc), mnCurTab(-1), mnCurCol(-1) {}
 163
 164     virtual void startColumn( ScColumn* pCol ) SAL_OVERRIDE
 165     {
 166         mnCurTab = pCol->GetTab();
 167         mnCurCol = pCol->GetCol();
 168     }
 169
 170     virtual void execute( SCROW nRow1, SCROW nRow2, bool bVal ) SAL_OVERRIDE
 171     {
 172         if (!bVal)
 173             return;
 174
 175         ScRange aRange(mnCurCol, nRow1, mnCurTab, mnCurCol, nRow2, mnCurTab);
 176         mrDoc.BroadcastCells(aRange, SC_HINT_DATACHANGED);
 177     };
 178 };
 179
 180 }
 181
 182 void ScSimpleUndo::BroadcastChanges( const DataSpansType& rSpans )
 183 {
 184     ScDocument& rDoc = pDocShell->GetDocument();
 185     SpanBroadcaster aBroadcaster(rDoc);
 186
 187     DataSpansType::const_iterator it = rSpans.begin(), itEnd = rSpans.end();
 188     for (; it != itEnd; ++it)
 189     {
 190         const sc::ColumnSpanSet& rSet = *it->second;
 191         rSet.executeColumnAction(rDoc, aBroadcaster);
 192     }
 193 }
 194
 195 void ScSimpleUndo::ShowTable( SCTAB nTab )
 196 {
 197     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 198     if (pViewShell)
 199         pViewShell->SetTabNo( nTab );
 200 }
 201
 202 void ScSimpleUndo::ShowTable( const ScRange& rRange )
 203 {
 204     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 205     if (pViewShell)
 206     {
 207         SCTAB nStart = rRange.aStart.Tab();
 208         SCTAB nEnd   = rRange.aEnd.Tab();
 209         SCTAB nTab = pViewShell->GetViewData().GetTabNo();
 210         if ( nTab < nStart || nTab > nEnd )                     // if not in range:
 211             pViewShell->SetTabNo( nStart );                     // at beginning of the range
 212     }
 213 }
 214
 215 ScBlockUndo::ScBlockUndo( ScDocShell* pDocSh, const ScRange& rRange,
 216                                             ScBlockUndoMode eBlockMode ) :
 217     ScSimpleUndo( pDocSh ),
 218     aBlockRange( rRange ),
 219     eMode( eBlockMode )
 220 {
 221     pDrawUndo = GetSdrUndoAction( &pDocShell->GetDocument() );
 222 }
 223
 224 ScBlockUndo::~ScBlockUndo()
 225 {
 226     DeleteSdrUndoAction( pDrawUndo );
 227 }
 228
 229 void ScBlockUndo::BeginUndo()
 230 {
 231     ScSimpleUndo::BeginUndo();
 232     EnableDrawAdjust( &pDocShell->GetDocument(), false );
 233 }
 234
 235 void ScBlockUndo::EndUndo()
 236 {
 237     if (eMode == SC_UNDO_AUTOHEIGHT)
 238         AdjustHeight();
 239
 240     EnableDrawAdjust( &pDocShell->GetDocument(), true );
 241     DoSdrUndoAction( pDrawUndo, &pDocShell->GetDocument() );
 242
 243     ShowBlock();
 244     ScSimpleUndo::EndUndo();
 245 }
 246
 247 void ScBlockUndo::EndRedo()
 248 {
 249     if (eMode == SC_UNDO_AUTOHEIGHT)
 250         AdjustHeight();
 251
 252     ShowBlock();
 253     ScSimpleUndo::EndRedo();
 254 }
 255
 256 bool ScBlockUndo::AdjustHeight()
 257 {
 258     ScDocument& rDoc = pDocShell->GetDocument();
 259
 260     ScopedVclPtrInstance< VirtualDevice > pVirtDev;
 261     Fraction aZoomX( 1, 1 );
 262     Fraction aZoomY = aZoomX;
 263     double nPPTX, nPPTY;
 264     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 265     if (pViewShell)
 266     {
 267         ScViewData& rData = pViewShell->GetViewData();
 268         nPPTX = rData.GetPPTX();
 269         nPPTY = rData.GetPPTY();
 270         aZoomX = rData.GetZoomX();
 271         aZoomY = rData.GetZoomY();
 272     }
 273     else
 274     {
 275         // Leave zoom at 100
 276         nPPTX = ScGlobal::nScreenPPTX;
 277         nPPTY = ScGlobal::nScreenPPTY;
 278     }
 279
 280     sc::RowHeightContext aCxt(nPPTX, nPPTY, aZoomX, aZoomY, pVirtDev);
 281     bool bRet = rDoc.SetOptimalHeight(
 282         aCxt, aBlockRange.aStart.Row(), aBlockRange.aEnd.Row(), aBlockRange.aStart.Tab());
 283
 284     if (bRet)
 285         pDocShell->PostPaint( 0,      aBlockRange.aStart.Row(), aBlockRange.aStart.Tab(),
 286                               MAXCOL, MAXROW,                   aBlockRange.aEnd.Tab(),
 287                               PAINT_GRID | PAINT_LEFT );
 288
 289     return bRet;
 290 }
 291
 292 void ScBlockUndo::ShowBlock()
 293 {
 294     if ( IsPaintLocked() )
 295         return;
 296
 297     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 298     if (pViewShell)
 299     {
 300         ShowTable( aBlockRange );       // with multiple sheets in range each of them is good
 301         pViewShell->MoveCursorAbs( aBlockRange.aStart.Col(), aBlockRange.aStart.Row(),
 302                                    SC_FOLLOW_JUMP, false, false );
 303         SCTAB nTab = pViewShell->GetViewData().GetTabNo();
 304         ScRange aRange = aBlockRange;
 305         aRange.aStart.SetTab( nTab );
 306         aRange.aEnd.SetTab( nTab );
 307         pViewShell->MarkRange( aRange );
 308
 309         // not through SetMarkArea to MarkData, due to possibly lacking paint
 310     }
 311 }
 312
 313 ScMultiBlockUndo::ScMultiBlockUndo(
 314     ScDocShell* pDocSh, const ScRangeList& rRanges, ScBlockUndoMode eBlockMode) :
 315     ScSimpleUndo(pDocSh),
 316     maBlockRanges(rRanges),
 317     meMode(eBlockMode)
 318 {
 319     mpDrawUndo = GetSdrUndoAction( &pDocShell->GetDocument() );
 320 }
 321
 322 ScMultiBlockUndo::~ScMultiBlockUndo()
 323 {
 324     DeleteSdrUndoAction( mpDrawUndo );
 325 }
 326
 327 void ScMultiBlockUndo::BeginUndo()
 328 {
 329     ScSimpleUndo::BeginUndo();
 330     EnableDrawAdjust(&pDocShell->GetDocument(), false);
 331 }
 332
 333 void ScMultiBlockUndo::EndUndo()
 334 {
 335     if (meMode == SC_UNDO_AUTOHEIGHT)
 336         AdjustHeight();
 337
 338     EnableDrawAdjust(&pDocShell->GetDocument(), true);
 339     DoSdrUndoAction(mpDrawUndo, &pDocShell->GetDocument());
 340
 341     ShowBlock();
 342     ScSimpleUndo::EndUndo();
 343 }
 344
 345 void ScMultiBlockUndo::EndRedo()
 346 {
 347     if (meMode == SC_UNDO_AUTOHEIGHT)
 348         AdjustHeight();
 349
 350     ShowBlock();
 351     ScSimpleUndo::EndRedo();
 352 }
 353
 354 void ScMultiBlockUndo::AdjustHeight()
 355 {
 356     ScDocument& rDoc = pDocShell->GetDocument();
 357
 358     ScopedVclPtrInstance< VirtualDevice > pVirtDev;
 359     Fraction aZoomX( 1, 1 );
 360     Fraction aZoomY = aZoomX;
 361     double nPPTX, nPPTY;
 362     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 363     if (pViewShell)
 364     {
 365         ScViewData& rData = pViewShell->GetViewData();
 366         nPPTX = rData.GetPPTX();
 367         nPPTY = rData.GetPPTY();
 368         aZoomX = rData.GetZoomX();
 369         aZoomY = rData.GetZoomY();
 370     }
 371     else
 372     {
 373         // Leave zoom at 100
 374         nPPTX = ScGlobal::nScreenPPTX;
 375         nPPTY = ScGlobal::nScreenPPTY;
 376     }
 377
 378     sc::RowHeightContext aCxt(nPPTX, nPPTY, aZoomX, aZoomY, pVirtDev);
 379     for (size_t i = 0, n = maBlockRanges.size(); i < n; ++i)
 380     {
 381         const ScRange& r = *maBlockRanges[i];
 382         bool bRet = rDoc.SetOptimalHeight(aCxt, r.aStart.Row(), r.aEnd.Row(), r.aStart.Tab());
 383
 384         if (bRet)
 385             pDocShell->PostPaint(
 386                 0, r.aStart.Row(), r.aStart.Tab(), MAXCOL, MAXROW, r.aEnd.Tab(),
 387                 PAINT_GRID | PAINT_LEFT);
 388     }
 389 }
 390
 391 void ScMultiBlockUndo::ShowBlock()
 392 {
 393     if ( IsPaintLocked() )
 394         return;
 395
 396     ScTabViewShell* pViewShell = ScTabViewShell::GetActiveViewShell();
 397     if (!pViewShell)
 398         return;
 399
 400     if (maBlockRanges.empty())
 401         return;
 402
 403     // Move to the sheet of the first range.
 404     ScRange aRange = *maBlockRanges.front();
 405     ShowTable(aRange);
 406     pViewShell->MoveCursorAbs(
 407         aRange.aStart.Col(), aRange.aStart.Row(), SC_FOLLOW_JUMP, false, false);
 408     SCTAB nTab = pViewShell->GetViewData().GetTabNo();
 409     aRange.aStart.SetTab(nTab);
 410     aRange.aEnd.SetTab(nTab);
 411     pViewShell->MarkRange(aRange, false, false);
 412
 413     for (size_t i = 1, n = maBlockRanges.size(); i < n; ++i)
 414     {
 415         aRange = *maBlockRanges[i];
 416         aRange.aStart.SetTab(nTab);
 417         aRange.aEnd.SetTab(nTab);
 418         pViewShell->MarkRange(aRange, false, true);
 419     }
 420 }
 421
 422 ScMoveUndo::ScMoveUndo( ScDocShell* pDocSh, ScDocument* pRefDoc, ScRefUndoData* pRefData,
 423                                                 ScMoveUndoMode eRefMode ) :
 424     ScSimpleUndo( pDocSh ),
 425     pRefUndoDoc( pRefDoc ),
 426     pRefUndoData( pRefData ),
 427     eMode( eRefMode )
 428 {
 429     ScDocument& rDoc = pDocShell->GetDocument();
 430     if (pRefUndoData)
 431         pRefUndoData->DeleteUnchanged(&rDoc);
 432     pDrawUndo = GetSdrUndoAction( &rDoc );
 433 }
 434
 435 ScMoveUndo::~ScMoveUndo()
 436 {
 437     delete pRefUndoData;
 438     delete pRefUndoDoc;
 439     DeleteSdrUndoAction( pDrawUndo );
 440 }
 441
 442 void ScMoveUndo::UndoRef()
 443 {
 444     ScDocument& rDoc = pDocShell->GetDocument();
 445     ScRange aRange(0,0,0, MAXCOL,MAXROW,pRefUndoDoc->GetTableCount()-1);
 446     pRefUndoDoc->CopyToDocument( aRange, IDF_FORMULA, false, &rDoc, NULL, false );
 447     if (pRefUndoData)
 448         pRefUndoData->DoUndo( &rDoc, (eMode == SC_UNDO_REFFIRST) );
 449         // HACK: ScDragDropUndo is the only one with REFFIRST.
 450         // If not, results possibly in a too frequent adjustment
 451         // of ChartRefs. Not that pretty, but not too bad either..
 452 }
 453
 454 void ScMoveUndo::BeginUndo()
 455 {
 456     ScSimpleUndo::BeginUndo();
 457
 458     EnableDrawAdjust( &pDocShell->GetDocument(), false );
 459
 460     if (pRefUndoDoc && eMode == SC_UNDO_REFFIRST)
 461         UndoRef();
 462 }
 463
 464 void ScMoveUndo::EndUndo()
 465 {
 466     DoSdrUndoAction( pDrawUndo, &pDocShell->GetDocument() );     // must also be called when pointer is null
 467
 468     if (pRefUndoDoc && eMode == SC_UNDO_REFLAST)
 469         UndoRef();
 470
 471     EnableDrawAdjust( &pDocShell->GetDocument(), true );
 472
 473     ScSimpleUndo::EndUndo();
 474 }
 475
 476 ScDBFuncUndo::ScDBFuncUndo( ScDocShell* pDocSh, const ScRange& rOriginal, SdrUndoAction* pDrawUndo ) :
 477     ScSimpleUndo( pDocSh ),
 478     aOriginalRange( rOriginal ),
 479     mpDrawUndo( pDrawUndo )
 480 {
 481     pAutoDBRange = pDocSh->GetOldAutoDBRange();
 482 }
 483
 484 ScDBFuncUndo::~ScDBFuncUndo()
 485 {
 486     DeleteSdrUndoAction( mpDrawUndo );
 487     delete pAutoDBRange;
 488 }
 489
 490 void ScDBFuncUndo::BeginUndo()
 491 {
 492     ScSimpleUndo::BeginUndo();
 493     DoSdrUndoAction( mpDrawUndo, &pDocShell->GetDocument() );
 494 }
 495
 496 void ScDBFuncUndo::EndUndo()
 497 {
 498     ScSimpleUndo::EndUndo();
 499
 500     if ( pAutoDBRange )
 501     {
 502         ScDocument& rDoc = pDocShell->GetDocument();
 503         SCTAB nTab = rDoc.GetVisibleTab();
 504         ScDBData* pNoNameData = rDoc.GetAnonymousDBData(nTab);
 505         if (pNoNameData )
 506         {
 507             SCCOL nRangeX1;
 508             SCROW nRangeY1;
 509             SCCOL nRangeX2;
 510             SCROW nRangeY2;
 511             SCTAB nRangeTab;
 512             pNoNameData->GetArea( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
 513             pDocShell->DBAreaDeleted( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
 514
 515             *pNoNameData = *pAutoDBRange;
 516
 517             if ( pAutoDBRange->HasAutoFilter() )
 518             {
 519                 // restore AutoFilter buttons
 520                 pAutoDBRange->GetArea( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
 521                 rDoc.ApplyFlagsTab( nRangeX1, nRangeY1, nRangeX2, nRangeY1, nRangeTab, SC_MF_AUTO );
 522                 pDocShell->PostPaint( nRangeX1, nRangeY1, nRangeTab, nRangeX2, nRangeY1, nRangeTab, PAINT_GRID );
 523             }
 524         }
 525     }
 526 }
 527
 528 void ScDBFuncUndo::BeginRedo()
 529 {
 530     RedoSdrUndoAction( mpDrawUndo );
 531     if ( pAutoDBRange )
 532     {
 533         // move the database range to this function's position again (see ScDocShell::GetDBData)
 534
 535         ScDocument& rDoc = pDocShell->GetDocument();
 536         ScDBData* pNoNameData = rDoc.GetAnonymousDBData(aOriginalRange.aStart.Tab());
 537         if ( pNoNameData )
 538         {
 539
 540             SCCOL nRangeX1;
 541             SCROW nRangeY1;
 542             SCCOL nRangeX2;
 543             SCROW nRangeY2;
 544             SCTAB nRangeTab;
 545             pNoNameData->GetArea( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
 546             pDocShell->DBAreaDeleted( nRangeTab, nRangeX1, nRangeY1, nRangeX2, nRangeY2 );
 547
 548             pNoNameData->SetSortParam( ScSortParam() );
 549             pNoNameData->SetQueryParam( ScQueryParam() );
 550             pNoNameData->SetSubTotalParam( ScSubTotalParam() );
 551
 552             pNoNameData->SetArea( aOriginalRange.aStart.Tab(),
 553                                   aOriginalRange.aStart.Col(), aOriginalRange.aStart.Row(),
 554                                   aOriginalRange.aEnd.Col(), aOriginalRange.aEnd.Row() );
 555
 556             pNoNameData->SetByRow( true );
 557             pNoNameData->SetAutoFilter( false );
 558             // header is always set with the operation in redo
 559         }
 560     }
 561
 562     ScSimpleUndo::BeginRedo();
 563 }
 564
 565 void ScDBFuncUndo::EndRedo()
 566 {
 567     ScSimpleUndo::EndRedo();
 568 }
 569
 570 ScUndoWrapper::ScUndoWrapper( SfxUndoAction* pUndo ) :
 571     pWrappedUndo( pUndo )
 572 {
 573 }
 574
 575 ScUndoWrapper::~ScUndoWrapper()
 576 {
 577     delete pWrappedUndo;
 578 }
 579
 580 void ScUndoWrapper::ForgetWrappedUndo()
 581 {
 582     pWrappedUndo = NULL;    // don't delete in dtor - pointer must be stored outside
 583 }
 584
 585 OUString ScUndoWrapper::GetComment() const
 586 {
 587     if (pWrappedUndo)
 588         return pWrappedUndo->GetComment();
 589     return OUString();
 590 }
 591
 592 OUString ScUndoWrapper::GetRepeatComment(SfxRepeatTarget& rTarget) const
 593 {
 594     if (pWrappedUndo)
 595         return pWrappedUndo->GetRepeatComment(rTarget);
 596     return OUString();
 597 }
 598
 599 sal_uInt16 ScUndoWrapper::GetId() const
 600 {
 601     if (pWrappedUndo)
 602         return pWrappedUndo->GetId();
 603     else
 604         return 0;
 605 }
 606
 607 void ScUndoWrapper::SetLinkToSfxLinkUndoAction(SfxLinkUndoAction* pSfxLinkUndoAction)
 608 {
 609     if (pWrappedUndo)
 610         pWrappedUndo->SetLinkToSfxLinkUndoAction(pSfxLinkUndoAction);
 611     else
 612         SetLinkToSfxLinkUndoAction(pSfxLinkUndoAction);
 613 }
 614
 615 bool ScUndoWrapper::Merge( SfxUndoAction* pNextAction )
 616 {
 617     if (pWrappedUndo)
 618         return pWrappedUndo->Merge(pNextAction);
 619     else
 620         return false;
 621 }
 622
 623 void ScUndoWrapper::Undo()
 624 {
 625     if (pWrappedUndo)
 626         pWrappedUndo->Undo();
 627 }
 628
 629 void ScUndoWrapper::Redo()
 630 {
 631     if (pWrappedUndo)
 632         pWrappedUndo->Redo();
 633 }
 634
 635 void ScUndoWrapper::Repeat(SfxRepeatTarget& rTarget)
 636 {
 637     if (pWrappedUndo)
 638         pWrappedUndo->Repeat(rTarget);
 639 }
 640
 641 bool ScUndoWrapper::CanRepeat(SfxRepeatTarget& rTarget) const
 642 {
 643     if (pWrappedUndo)
 644         return pWrappedUndo->CanRepeat(rTarget);
 645     else
 646         return false;
 647 }
 648
 649 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */